Design Challenge: metrics missing value...

> Hi dear great OO designers
>
> Here is a little challenges for your brainy souls :)
>
> In Moose when we compute metrics it may happen than a tool (often external
> to pharo) does not compute a metrics
> and when we request it in moose we check and often we return a not so good
> -1.
>
> I'm trying to brainstorm on a solution
>
> - first may be the simplest way is to not invoke a metrics when it is not
> computed. But it means that we should know it and that we should have a
> registration mechanism. After all this is probably the best solution.
>
> - Second we were thinking to use exception but when we have multiple
> entities missing one metrics.... I have serious doubts.
>
> - Second I was thinking about having the following behavior
>
> testCollect
>
>         | uarray collected |
>         uarray := UniformOrderedCollection new.
>         uarray add: 10.
>         uarray add: 20.
>         uarray add: (MissingValue discarding).
>         collected := uarray collect: [ :each | each ].
>         self assert: collected size equals: 2.
>
> testDo
>
>         | res uarray |
>         uarray := UniformOrderedCollection new.
>         uarray add: 10.
>         uarray add: 20.
>         uarray add: (MissingValue discarding).
>         uarray add: 40.
>         res := 0.
>         uarray do: [ :each | res := res + each ].
>         self assert: res equals: 70.
>
>
> testCollectDefaulting
>
>         | uarray collected |
>         uarray := UniformOrderedCollection new.
>         uarray add: 10.
>         uarray add: 20.
>         uarray add: (MissingValue default: 33).
>         collected := uarray collect: [ :each | each ].
>         self assert: collected size equals: 3.
>         self assert: collected third equals: 33
>
>
> I basically started to implement
>
>
> do: aBlock
>         "Refer to the comment in Collection|do:."
>         1 to: self size do:
>                 [:index | (self at: index) toDo: aBlock on: self]
>
>
>
> collect: aBlock
>         "Evaluate aBlock with each of the receiver's elements as the
> argument.
>         Collect the resulting values into a collection like the receiver.
> Answer
>         the new collection."
>
>         | newCollection |
>         newCollection := self species new.
>         self
>                 do: [ :each | each toCollect: aBlock on: newCollection ].
>         ^ newCollection
>
>
> and
>
> DiscardingValue >> toCollect: aBlock on: aCollection
>         "discard computation"
>         ^ self
>
>
> Object >> toCollect: aBlock on: aCollection
>
>         ^ aCollection add: (aBlock value: self)
>
>
> So I imagine that you see the design and I wanted to get your point of view.
>
> --
> Using Opera a kind of bad mail client but far better than thunderbird
> _______________________________________________
> Moose-dev mailing list
> [hidden email]
> https://www.list.inf.unibe.ch/listinfo/moose-dev

> On Dec 20, 2016, at 10:15 PM, stepharong <[hidden email]> wrote:
>
> Hi dear great OO designers
>
> Here is a little challenges for your brainy souls :)
>
> In Moose when we compute metrics it may happen than a tool (often external to pharo) does not compute a metrics
> and when we request it in moose we check and often we return a not so good -1.
>
> I'm trying to brainstorm on a solution
>
> - first may be the simplest way is to not invoke a metrics when it is not computed. But it means that we should know it and that we should have a registration mechanism. After all this is probably the best solution.
>
> - Second we were thinking to use exception but when we have multiple entities missing one metrics.... I have serious doubts.
>
> - Second I was thinking about having the following behavior
>
> testCollect
>
> | uarray collected |
> uarray := UniformOrderedCollection new.
> uarray add: 10.
> uarray add: 20.
> uarray add: (MissingValue discarding).
> collected := uarray collect: [ :each | each ].
> self assert: collected size equals: 2.
>
> testDo
>
> | res uarray |
> uarray := UniformOrderedCollection new.
> uarray add: 10.
> uarray add: 20.
> uarray add: (MissingValue discarding).
> uarray add: 40.
> res := 0.
> uarray do: [ :each | res := res + each ].
> self assert: res equals: 70.
>
>
> testCollectDefaulting
>
> | uarray collected |
> uarray := UniformOrderedCollection new.
> uarray add: 10.
> uarray add: 20.
> uarray add: (MissingValue default: 33).
> collected := uarray collect: [ :each | each ].
> self assert: collected size equals: 3.
> self assert: collected third equals: 33
>
>
> I basically started to implement
>
>
> do: aBlock
> "Refer to the comment in Collection|do:."
> 1 to: self size do:
> [:index | (self at: index) toDo: aBlock on: self]
>
>
>
> collect: aBlock
> "Evaluate aBlock with each of the receiver's elements as the argument.
> Collect the resulting values into a collection like the receiver. Answer
> the new collection."
>
> | newCollection |
> newCollection := self species new.
> self
> do: [ :each | each toCollect: aBlock on: newCollection ].
> ^ newCollection
>
>
> and
>
> DiscardingValue >> toCollect: aBlock on: aCollection
> "discard computation"
> ^ self
>
>
> Object >> toCollect: aBlock on: aCollection
>
> ^ aCollection add: (aBlock value: self)
>
>
> So I imagine that you see the design and I wanted to get your point of view.
>
> --
> Using Opera a kind of bad mail client but far better than thunderbird
> _______________________________________________
> Moose-dev mailing list
> [hidden email]
> https://www.list.inf.unibe.ch/listinfo/moose-dev

> On Dec 20, 2016, at 10:15 PM, stepharong <[hidden email]> wrote:
>
> Hi dear great OO designers
>
> Here is a little challenges for your brainy souls :)
>
> In Moose when we compute metrics it may happen than a tool (often external to pharo) does not compute a metrics
> and when we request it in moose we check and often we return a not so good -1.
>
> I'm trying to brainstorm on a solution
>
> - first may be the simplest way is to not invoke a metrics when it is not computed. But it means that we should know it and that we should have a registration mechanism. After all this is probably the best solution.
>
> - Second we were thinking to use exception but when we have multiple entities missing one metrics.... I have serious doubts.
>
> - Second I was thinking about having the following behavior
>
> testCollect
>
> | uarray collected |
> uarray := UniformOrderedCollection new.
> uarray add: 10.
> uarray add: 20.
> uarray add: (MissingValue discarding).
> collected := uarray collect: [ :each | each ].
> self assert: collected size equals: 2.
>
> testDo
>
> | res uarray |
> uarray := UniformOrderedCollection new.
> uarray add: 10.
> uarray add: 20.
> uarray add: (MissingValue discarding).
> uarray add: 40.
> res := 0.
> uarray do: [ :each | res := res + each ].
> self assert: res equals: 70.
>
>
> testCollectDefaulting
>
> | uarray collected |
> uarray := UniformOrderedCollection new.
> uarray add: 10.
> uarray add: 20.
> uarray add: (MissingValue default: 33).
> collected := uarray collect: [ :each | each ].
> self assert: collected size equals: 3.
> self assert: collected third equals: 33
>
>
> I basically started to implement
>
>
> do: aBlock
> "Refer to the comment in Collection|do:."
> 1 to: self size do:
> [:index | (self at: index) toDo: aBlock on: self]
>
>
>
> collect: aBlock
> "Evaluate aBlock with each of the receiver's elements as the argument.
> Collect the resulting values into a collection like the receiver. Answer
> the new collection."
>
> | newCollection |
> newCollection := self species new.
> self
> do: [ :each | each toCollect: aBlock on: newCollection ].
> ^ newCollection
>
>
> and
>
> DiscardingValue >> toCollect: aBlock on: aCollection
> "discard computation"
> ^ self
>
>
> Object >> toCollect: aBlock on: aCollection
>
> ^ aCollection add: (aBlock value: self)
>
>
> So I imagine that you see the design and I wanted to get your point of view.
>
> --
> Using Opera a kind of bad mail client but far better than thunderbird
> _______________________________________________
> Moose-dev mailing list
> [hidden email]
> https://www.list.inf.unibe.ch/listinfo/moose-dev

> On Dec 21, 2016, at 8:13 AM, Alexandre Bergel <[hidden email]> wrote:
>
> Hi Stef,
>
> You are raising an interesting point to discuss. This MissingValue is indeed better than having -1
> Something to keep in mind: it may be that one would like to focus on the missing value and not really the value.
>
> Consider:
>
>> testCollect
>>
>> | uarray collected |
>> uarray := UniformOrderedCollection new.
>> uarray add: 10.
>> uarray add: 20.
>> uarray add: (MissingValue discarding).
>> collected := uarray collect: [ :each | each ].
>> self assert: collected size equals: 2.
>
> It could well be that I would like to be able to query over the MissingValue.
> Can something like possible: uarray collect: #isMissing
> ?
>
> Cheers,
> Alexandre
>
>
>> On Dec 20, 2016, at 10:15 PM, stepharong <[hidden email]> wrote:
>>
>> Hi dear great OO designers
>>
>> Here is a little challenges for your brainy souls :)
>>
>> In Moose when we compute metrics it may happen than a tool (often external to pharo) does not compute a metrics
>> and when we request it in moose we check and often we return a not so good -1.
>>
>> I'm trying to brainstorm on a solution
>>
>> - first may be the simplest way is to not invoke a metrics when it is not computed. But it means that we should know it and that we should have a registration mechanism. After all this is probably the best solution.
>>
>> - Second we were thinking to use exception but when we have multiple entities missing one metrics.... I have serious doubts.
>>
>> - Second I was thinking about having the following behavior
>>
>> testCollect
>>
>> | uarray collected |
>> uarray := UniformOrderedCollection new.
>> uarray add: 10.
>> uarray add: 20.
>> uarray add: (MissingValue discarding).
>> collected := uarray collect: [ :each | each ].
>> self assert: collected size equals: 2.
>>
>> testDo
>>
>> | res uarray |
>> uarray := UniformOrderedCollection new.
>> uarray add: 10.
>> uarray add: 20.
>> uarray add: (MissingValue discarding).
>> uarray add: 40.
>> res := 0.
>> uarray do: [ :each | res := res + each ].
>> self assert: res equals: 70.
>>
>>
>> testCollectDefaulting
>>
>> | uarray collected |
>> uarray := UniformOrderedCollection new.
>> uarray add: 10.
>> uarray add: 20.
>> uarray add: (MissingValue default: 33).
>> collected := uarray collect: [ :each | each ].
>> self assert: collected size equals: 3.
>> self assert: collected third equals: 33
>>
>>
>> I basically started to implement
>>
>>
>> do: aBlock
>> "Refer to the comment in Collection|do:."
>> 1 to: self size do:
>> [:index | (self at: index) toDo: aBlock on: self]
>>
>>
>>
>> collect: aBlock
>> "Evaluate aBlock with each of the receiver's elements as the argument.
>> Collect the resulting values into a collection like the receiver. Answer
>> the new collection."
>>
>> | newCollection |
>> newCollection := self species new.
>> self
>> do: [ :each | each toCollect: aBlock on: newCollection ].
>> ^ newCollection
>>
>>
>> and
>>
>> DiscardingValue >> toCollect: aBlock on: aCollection
>> "discard computation"
>> ^ self
>>
>>
>> Object >> toCollect: aBlock on: aCollection
>>
>> ^ aCollection add: (aBlock value: self)
>>
>>
>> So I imagine that you see the design and I wanted to get your point of view.
>>
>> --
>> Using Opera a kind of bad mail client but far better than thunderbird
>> _______________________________________________
>> Moose-dev mailing list
>> [hidden email]
>> https://www.list.inf.unibe.ch/listinfo/moose-dev
>
> --
> _,.;:~^~:;._,.;:~^~:;._,.;:~^~:;._,.;:~^~:;._,.;:
> Alexandre Bergel  http://www.bergel.eu
> ^~:;._,.;:~^~:;._,.;:~^~:;._,.;:~^~:;._,.;:~^~:;.
>
>
>
> _______________________________________________
> Moose-dev mailing list
> [hidden email]
> https://www.list.inf.unibe.ch/listinfo/moose-dev

> On 21 Dec 2016, at 08:21, Tudor Girba <[hidden email]> wrote:
>
> Hi Alex,
>
> Following the design proposed by Stef, in your case you would use a different collection.
>
> Cheers,
> Doru
>
>
>> On Dec 21, 2016, at 8:13 AM, Alexandre Bergel <[hidden email]> wrote:
>>
>> Hi Stef,
>>
>> You are raising an interesting point to discuss. This MissingValue is indeed better than having -1
>> Something to keep in mind: it may be that one would like to focus on the missing value and not really the value.
>>
>> Consider:
>>
>>> testCollect
>>>
>>>    | uarray collected |
>>>    uarray := UniformOrderedCollection new.
>>>    uarray add: 10.
>>>    uarray add: 20.
>>>    uarray add: (MissingValue discarding).
>>>    collected := uarray collect: [ :each | each ].    
>>>    self assert: collected size equals: 2.
>>
>> It could well be that I would like to be able to query over the MissingValue.
>> Can something like possible: uarray collect: #isMissing
>> ?
>>
>> Cheers,
>> Alexandre
>>
>>
>>> On Dec 20, 2016, at 10:15 PM, stepharong <[hidden email]> wrote:
>>>
>>> Hi dear great OO designers
>>>
>>> Here is a little challenges for your brainy souls :)
>>>
>>> In Moose when we compute metrics it may happen than a tool (often external to pharo) does not compute a metrics
>>> and when we request it in moose we check and often we return a not so good -1.
>>>
>>> I'm trying to brainstorm on a solution
>>>
>>> - first may be the simplest way is to not invoke a metrics when it is not computed. But it means that we should know it and that we should have a registration mechanism. After all this is probably the best solution.
>>>
>>> - Second we were thinking to use exception but when we have multiple entities missing one metrics.... I have serious doubts.
>>>
>>> - Second I was thinking about having the following behavior
>>>
>>> testCollect
>>>
>>>    | uarray collected |
>>>    uarray := UniformOrderedCollection new.
>>>    uarray add: 10.
>>>    uarray add: 20.
>>>    uarray add: (MissingValue discarding).
>>>    collected := uarray collect: [ :each | each ].    
>>>    self assert: collected size equals: 2.
>>>
>>> testDo
>>>
>>>    | res uarray |
>>>    uarray := UniformOrderedCollection new.
>>>    uarray add: 10.
>>>    uarray add: 20.
>>>    uarray add: (MissingValue discarding).
>>>    uarray add: 40.
>>>    res := 0.
>>>    uarray do: [ :each | res := res + each ].    
>>>    self assert: res equals: 70.
>>>
>>>
>>> testCollectDefaulting
>>>
>>>    | uarray collected |
>>>    uarray := UniformOrderedCollection new.
>>>    uarray add: 10.
>>>    uarray add: 20.
>>>    uarray add: (MissingValue default: 33).
>>>    collected := uarray collect: [ :each | each ].    
>>>    self assert: collected size equals: 3.
>>>    self assert: collected third equals: 33
>>>
>>>
>>> I basically started to implement
>>>
>>>
>>> do: aBlock
>>>    "Refer to the comment in Collection|do:."
>>>    1 to: self size do:
>>>        [:index | (self at: index) toDo: aBlock on: self]
>>>
>>>
>>>
>>> collect: aBlock
>>>    "Evaluate aBlock with each of the receiver's elements as the argument.
>>>    Collect the resulting values into a collection like the receiver. Answer
>>>    the new collection."
>>>
>>>    | newCollection |
>>>    newCollection := self species new.
>>>    self
>>>        do: [ :each | each toCollect: aBlock on: newCollection ].
>>>    ^ newCollection
>>>
>>>
>>> and
>>>
>>> DiscardingValue >> toCollect: aBlock on: aCollection
>>>    "discard computation"
>>>    ^ self
>>>
>>>
>>> Object >> toCollect: aBlock on: aCollection
>>>
>>>    ^ aCollection add: (aBlock value: self)
>>>
>>>
>>> So I imagine that you see the design and I wanted to get your point of view.
>>>
>>> --
>>> Using Opera a kind of bad mail client but far better than thunderbird
>>> _______________________________________________
>>> Moose-dev mailing list
>>> [hidden email]
>>> https://www.list.inf.unibe.ch/listinfo/moose-dev
>>
>> --
>> _,.;:~^~:;._,.;:~^~:;._,.;:~^~:;._,.;:~^~:;._,.;:
>> Alexandre Bergel  http://www.bergel.eu
>> ^~:;._,.;:~^~:;._,.;:~^~:;._,.;:~^~:;._,.;:~^~:;.
>>
>>
>>
>> _______________________________________________
>> Moose-dev mailing list
>> [hidden email]
>> https://www.list.inf.unibe.ch/listinfo/moose-dev
>
> --
> www.tudorgirba.com
> www.feenk.com
>
> "If you interrupt the barber while he is cutting your hair,
> you will end up with a messy haircut."
>

>
> Cheers,
> Doru
>
>
>> On Dec 20, 2016, at 10:15 PM, stepharong <[hidden email]> wrote:
>>
>> Hi dear great OO designers
>>
>> Here is a little challenges for your brainy souls :)
>>
>> In Moose when we compute metrics it may happen than a tool (often  
>> external to pharo) does not compute a metrics
>> and when we request it in moose we check and often we return a not so  
>> good -1.
>>
>> I'm trying to brainstorm on a solution
>>
>> - first may be the simplest way is to not invoke a metrics when it is  
>> not computed. But it means that we should know it and that we should  
>> have a registration mechanism. After all this is probably the best  
>> solution.
>>
>> - Second we were thinking to use exception but when we have multiple  
>> entities missing one metrics.... I have serious doubts.
>>
>> - Second I was thinking about having the following behavior
>>
>> testCollect
>>
>> | uarray collected |
>> uarray := UniformOrderedCollection new.
>> uarray add: 10.
>> uarray add: 20.
>> uarray add: (MissingValue discarding).
>> collected := uarray collect: [ :each | each ].
>> self assert: collected size equals: 2.
>>
>> testDo
>>
>> | res uarray |
>> uarray := UniformOrderedCollection new.
>> uarray add: 10.
>> uarray add: 20.
>> uarray add: (MissingValue discarding).
>> uarray add: 40.
>> res := 0.
>> uarray do: [ :each | res := res + each ].
>> self assert: res equals: 70.
>>
>>
>> testCollectDefaulting
>>
>> | uarray collected |
>> uarray := UniformOrderedCollection new.
>> uarray add: 10.
>> uarray add: 20.
>> uarray add: (MissingValue default: 33).
>> collected := uarray collect: [ :each | each ].
>> self assert: collected size equals: 3.
>> self assert: collected third equals: 33
>>
>>
>> I basically started to implement
>>
>>
>> do: aBlock
>> "Refer to the comment in Collection|do:."
>> 1 to: self size do:
>> [:index | (self at: index) toDo: aBlock on: self]
>>
>>
>>
>> collect: aBlock
>> "Evaluate aBlock with each of the receiver's elements as the argument.
>> Collect the resulting values into a collection like the receiver.  
>> Answer
>> the new collection."
>>
>> | newCollection |
>> newCollection := self species new.
>> self
>> do: [ :each | each toCollect: aBlock on: newCollection ].
>> ^ newCollection
>>
>>
>> and
>>
>> DiscardingValue >> toCollect: aBlock on: aCollection
>> "discard computation"
>> ^ self
>>
>>
>> Object >> toCollect: aBlock on: aCollection
>>
>> ^ aCollection add: (aBlock value: self)
>>
>>
>> So I imagine that you see the design and I wanted to get your point of  
>> view.
>>
>> --
>> Using Opera a kind of bad mail client but far better than thunderbird
>> _______________________________________________
>> Moose-dev mailing list
>> [hidden email]
>> https://www.list.inf.unibe.ch/listinfo/moose-dev
>
> --
> www.tudorgirba.com
> www.feenk.com
>
> "One cannot do more than one can do."
>
>
>
>
>

>
> Consider:
>
>> testCollect
>>
>> | uarray collected |
>> uarray := UniformOrderedCollection new.
>> uarray add: 10.
>> uarray add: 20.
>> uarray add: (MissingValue discarding).
>> collected := uarray collect: [ :each | each ].
>> self assert: collected size equals: 2.
>
> It could well be that I would like to be able to query over the  
> MissingValue.
> Can something like possible: uarray collect: #isMissing

>
> Cheers,
> Alexandre
>
>
>> On Dec 20, 2016, at 10:15 PM, stepharong <[hidden email]> wrote:
>>
>> Hi dear great OO designers
>>
>> Here is a little challenges for your brainy souls :)
>>
>> In Moose when we compute metrics it may happen than a tool (often  
>> external to pharo) does not compute a metrics
>> and when we request it in moose we check and often we return a not so  
>> good -1.
>>
>> I'm trying to brainstorm on a solution
>>
>> - first may be the simplest way is to not invoke a metrics when it is  
>> not computed. But it means that we should know it and that we should  
>> have a registration mechanism. After all this is probably the best  
>> solution.
>>
>> - Second we were thinking to use exception but when we have multiple  
>> entities missing one metrics.... I have serious doubts.
>>
>> - Second I was thinking about having the following behavior
>>
>> testCollect
>>
>> | uarray collected |
>> uarray := UniformOrderedCollection new.
>> uarray add: 10.
>> uarray add: 20.
>> uarray add: (MissingValue discarding).
>> collected := uarray collect: [ :each | each ].
>> self assert: collected size equals: 2.
>>
>> testDo
>>
>> | res uarray |
>> uarray := UniformOrderedCollection new.
>> uarray add: 10.
>> uarray add: 20.
>> uarray add: (MissingValue discarding).
>> uarray add: 40.
>> res := 0.
>> uarray do: [ :each | res := res + each ].
>> self assert: res equals: 70.
>>
>>
>> testCollectDefaulting
>>
>> | uarray collected |
>> uarray := UniformOrderedCollection new.
>> uarray add: 10.
>> uarray add: 20.
>> uarray add: (MissingValue default: 33).
>> collected := uarray collect: [ :each | each ].
>> self assert: collected size equals: 3.
>> self assert: collected third equals: 33
>>
>>
>> I basically started to implement
>>
>>
>> do: aBlock
>> "Refer to the comment in Collection|do:."
>> 1 to: self size do:
>> [:index | (self at: index) toDo: aBlock on: self]
>>
>>
>>
>> collect: aBlock
>> "Evaluate aBlock with each of the receiver's elements as the argument.
>> Collect the resulting values into a collection like the receiver.  
>> Answer
>> the new collection."
>>
>> | newCollection |
>> newCollection := self species new.
>> self
>> do: [ :each | each toCollect: aBlock on: newCollection ].
>> ^ newCollection
>>
>>
>> and
>>
>> DiscardingValue >> toCollect: aBlock on: aCollection
>> "discard computation"
>> ^ self
>>
>>
>> Object >> toCollect: aBlock on: aCollection
>>
>> ^ aCollection add: (aBlock value: self)
>>
>>
>> So I imagine that you see the design and I wanted to get your point of  
>> view.
>>
>> --
>> Using Opera a kind of bad mail client but far better than thunderbird
>> _______________________________________________
>> Moose-dev mailing list
>> [hidden email]
>> https://www.list.inf.unibe.ch/listinfo/moose-dev
>

>
> Cheers,
> Doru
>
>
>> On Dec 21, 2016, at 8:13 AM, Alexandre Bergel <[hidden email]>  
>> wrote:
>>
>> Hi Stef,
>>
>> You are raising an interesting point to discuss. This MissingValue is  
>> indeed better than having -1
>> Something to keep in mind: it may be that one would like to focus on  
>> the missing value and not really the value.
>>
>> Consider:
>>
>>> testCollect
>>>
>>> | uarray collected |
>>> uarray := UniformOrderedCollection new.
>>> uarray add: 10.
>>> uarray add: 20.
>>> uarray add: (MissingValue discarding).
>>> collected := uarray collect: [ :each | each ].
>>> self assert: collected size equals: 2.
>>
>> It could well be that I would like to be able to query over the  
>> MissingValue.
>> Can something like possible: uarray collect: #isMissing
>> ?
>>
>> Cheers,
>> Alexandre
>>
>>
>>> On Dec 20, 2016, at 10:15 PM, stepharong <[hidden email]> wrote:
>>>
>>> Hi dear great OO designers
>>>
>>> Here is a little challenges for your brainy souls :)
>>>
>>> In Moose when we compute metrics it may happen than a tool (often  
>>> external to pharo) does not compute a metrics
>>> and when we request it in moose we check and often we return a not so  
>>> good -1.
>>>
>>> I'm trying to brainstorm on a solution
>>>
>>> - first may be the simplest way is to not invoke a metrics when it is  
>>> not computed. But it means that we should know it and that we should  
>>> have a registration mechanism. After all this is probably the best  
>>> solution.
>>>
>>> - Second we were thinking to use exception but when we have multiple  
>>> entities missing one metrics.... I have serious doubts.
>>>
>>> - Second I was thinking about having the following behavior
>>>
>>> testCollect
>>>
>>> | uarray collected |
>>> uarray := UniformOrderedCollection new.
>>> uarray add: 10.
>>> uarray add: 20.
>>> uarray add: (MissingValue discarding).
>>> collected := uarray collect: [ :each | each ].
>>> self assert: collected size equals: 2.
>>>
>>> testDo
>>>
>>> | res uarray |
>>> uarray := UniformOrderedCollection new.
>>> uarray add: 10.
>>> uarray add: 20.
>>> uarray add: (MissingValue discarding).
>>> uarray add: 40.
>>> res := 0.
>>> uarray do: [ :each | res := res + each ].
>>> self assert: res equals: 70.
>>>
>>>
>>> testCollectDefaulting
>>>
>>> | uarray collected |
>>> uarray := UniformOrderedCollection new.
>>> uarray add: 10.
>>> uarray add: 20.
>>> uarray add: (MissingValue default: 33).
>>> collected := uarray collect: [ :each | each ].
>>> self assert: collected size equals: 3.
>>> self assert: collected third equals: 33
>>>
>>>
>>> I basically started to implement
>>>
>>>
>>> do: aBlock
>>> "Refer to the comment in Collection|do:."
>>> 1 to: self size do:
>>> [:index | (self at: index) toDo: aBlock on: self]
>>>
>>>
>>>
>>> collect: aBlock
>>> "Evaluate aBlock with each of the receiver's elements as the argument.
>>> Collect the resulting values into a collection like the receiver.  
>>> Answer
>>> the new collection."
>>>
>>> | newCollection |
>>> newCollection := self species new.
>>> self
>>> do: [ :each | each toCollect: aBlock on: newCollection ].
>>> ^ newCollection
>>>
>>>
>>> and
>>>
>>> DiscardingValue >> toCollect: aBlock on: aCollection
>>> "discard computation"
>>> ^ self
>>>
>>>
>>> Object >> toCollect: aBlock on: aCollection
>>>
>>> ^ aCollection add: (aBlock value: self)
>>>
>>>
>>> So I imagine that you see the design and I wanted to get your point of  
>>> view.
>>>
>>> --
>>> Using Opera a kind of bad mail client but far better than thunderbird
>>> _______________________________________________
>>> Moose-dev mailing list
>>> [hidden email]
>>> https://www.list.inf.unibe.ch/listinfo/moose-dev
>>
>> --
>> _,.;:~^~:;._,.;:~^~:;._,.;:~^~:;._,.;:~^~:;._,.;:
>> Alexandre Bergel  http://www.bergel.eu
>> ^~:;._,.;:~^~:;._,.;:~^~:;._,.;:~^~:;._,.;:~^~:;.
>>
>>
>>
>> _______________________________________________
>> Moose-dev mailing list
>> [hidden email]
>> https://www.list.inf.unibe.ch/listinfo/moose-dev
>
> --
> www.tudorgirba.com
> www.feenk.com
>
> "If you interrupt the barber while he is cutting your hair,
> you will end up with a messy haircut."
>
>

>
> Cheers,
> Doru
>
> --
> www.tudorgirba.com
>
> "Every thing has its own flow"
>
>> On 21 Dec 2016, at 08:21, Tudor Girba <[hidden email]> wrote:
>>
>> Hi Alex,
>>
>> Following the design proposed by Stef, in your case you would use a  
>> different collection.
>>
>> Cheers,
>> Doru
>>
>>
>>> On Dec 21, 2016, at 8:13 AM, Alexandre Bergel  
>>> <[hidden email]> wrote:
>>>
>>> Hi Stef,
>>>
>>> You are raising an interesting point to discuss. This MissingValue is  
>>> indeed better than having -1
>>> Something to keep in mind: it may be that one would like to focus on  
>>> the missing value and not really the value.
>>>
>>> Consider:
>>>
>>>> testCollect
>>>>
>>>>    | uarray collected |
>>>>    uarray := UniformOrderedCollection new.
>>>>    uarray add: 10.
>>>>    uarray add: 20.
>>>>    uarray add: (MissingValue discarding).
>>>>    collected := uarray collect: [ :each | each ].
>>>>    self assert: collected size equals: 2.
>>>
>>> It could well be that I would like to be able to query over the  
>>> MissingValue.
>>> Can something like possible: uarray collect: #isMissing
>>> ?
>>>
>>> Cheers,
>>> Alexandre
>>>
>>>
>>>> On Dec 20, 2016, at 10:15 PM, stepharong <[hidden email]> wrote:
>>>>
>>>> Hi dear great OO designers
>>>>
>>>> Here is a little challenges for your brainy souls :)
>>>>
>>>> In Moose when we compute metrics it may happen than a tool (often  
>>>> external to pharo) does not compute a metrics
>>>> and when we request it in moose we check and often we return a not so  
>>>> good -1.
>>>>
>>>> I'm trying to brainstorm on a solution
>>>>
>>>> - first may be the simplest way is to not invoke a metrics when it is  
>>>> not computed. But it means that we should know it and that we should  
>>>> have a registration mechanism. After all this is probably the best  
>>>> solution.
>>>>
>>>> - Second we were thinking to use exception but when we have multiple  
>>>> entities missing one metrics.... I have serious doubts.
>>>>
>>>> - Second I was thinking about having the following behavior
>>>>
>>>> testCollect
>>>>
>>>>    | uarray collected |
>>>>    uarray := UniformOrderedCollection new.
>>>>    uarray add: 10.
>>>>    uarray add: 20.
>>>>    uarray add: (MissingValue discarding).
>>>>    collected := uarray collect: [ :each | each ].
>>>>    self assert: collected size equals: 2.
>>>>
>>>> testDo
>>>>
>>>>    | res uarray |
>>>>    uarray := UniformOrderedCollection new.
>>>>    uarray add: 10.
>>>>    uarray add: 20.
>>>>    uarray add: (MissingValue discarding).
>>>>    uarray add: 40.
>>>>    res := 0.
>>>>    uarray do: [ :each | res := res + each ].
>>>>    self assert: res equals: 70.
>>>>
>>>>
>>>> testCollectDefaulting
>>>>
>>>>    | uarray collected |
>>>>    uarray := UniformOrderedCollection new.
>>>>    uarray add: 10.
>>>>    uarray add: 20.
>>>>    uarray add: (MissingValue default: 33).
>>>>    collected := uarray collect: [ :each | each ].
>>>>    self assert: collected size equals: 3.
>>>>    self assert: collected third equals: 33
>>>>
>>>>
>>>> I basically started to implement
>>>>
>>>>
>>>> do: aBlock
>>>>    "Refer to the comment in Collection|do:."
>>>>    1 to: self size do:
>>>>        [:index | (self at: index) toDo: aBlock on: self]
>>>>
>>>>
>>>>
>>>> collect: aBlock
>>>>    "Evaluate aBlock with each of the receiver's elements as the  
>>>> argument.
>>>>    Collect the resulting values into a collection like the receiver.  
>>>> Answer
>>>>    the new collection."
>>>>
>>>>    | newCollection |
>>>>    newCollection := self species new.
>>>>    self
>>>>        do: [ :each | each toCollect: aBlock on: newCollection ].
>>>>    ^ newCollection
>>>>
>>>>
>>>> and
>>>>
>>>> DiscardingValue >> toCollect: aBlock on: aCollection
>>>>    "discard computation"
>>>>    ^ self
>>>>
>>>>
>>>> Object >> toCollect: aBlock on: aCollection
>>>>
>>>>    ^ aCollection add: (aBlock value: self)
>>>>
>>>>
>>>> So I imagine that you see the design and I wanted to get your point  
>>>> of view.
>>>>
>>>> --
>>>> Using Opera a kind of bad mail client but far better than thunderbird
>>>> _______________________________________________
>>>> Moose-dev mailing list
>>>> [hidden email]
>>>> https://www.list.inf.unibe.ch/listinfo/moose-dev
>>>
>>> --
>>> _,.;:~^~:;._,.;:~^~:;._,.;:~^~:;._,.;:~^~:;._,.;:
>>> Alexandre Bergel  http://www.bergel.eu
>>> ^~:;._,.;:~^~:;._,.;:~^~:;._,.;:~^~:;._,.;:~^~:;.
>>>
>>>
>>>
>>> _______________________________________________
>>> Moose-dev mailing list
>>> [hidden email]
>>> https://www.list.inf.unibe.ch/listinfo/moose-dev
>>
>> --
>> www.tudorgirba.com
>> www.feenk.com
>>
>> "If you interrupt the barber while he is cutting your hair,
>> you will end up with a messy haircut."
>>
>

>
>>
>> Cheers,
>> Doru
>>
>>
>>> On Dec 21, 2016, at 8:13 AM, Alexandre Bergel <[hidden email]> wrote:
>>>
>>> Hi Stef,
>>>
>>> You are raising an interesting point to discuss. This MissingValue is indeed better than having -1
>>> Something to keep in mind: it may be that one would like to focus on the missing value and not really the value.
>>>
>>> Consider:
>>>
>>>> testCollect
>>>>
>>>> | uarray collected |
>>>> uarray := UniformOrderedCollection new.
>>>> uarray add: 10.
>>>> uarray add: 20.
>>>> uarray add: (MissingValue discarding).
>>>> collected := uarray collect: [ :each | each ].
>>>> self assert: collected size equals: 2.
>>>
>>> It could well be that I would like to be able to query over the MissingValue.
>>> Can something like possible: uarray collect: #isMissing
>>> ?
>>>
>>> Cheers,
>>> Alexandre
>>>
>>>
>>>> On Dec 20, 2016, at 10:15 PM, stepharong <[hidden email]> wrote:
>>>>
>>>> Hi dear great OO designers
>>>>
>>>> Here is a little challenges for your brainy souls :)
>>>>
>>>> In Moose when we compute metrics it may happen than a tool (often external to pharo) does not compute a metrics
>>>> and when we request it in moose we check and often we return a not so good -1.
>>>>
>>>> I'm trying to brainstorm on a solution
>>>>
>>>> - first may be the simplest way is to not invoke a metrics when it is not computed. But it means that we should know it and that we should have a registration mechanism. After all this is probably the best solution.
>>>>
>>>> - Second we were thinking to use exception but when we have multiple entities missing one metrics.... I have serious doubts.
>>>>
>>>> - Second I was thinking about having the following behavior
>>>>
>>>> testCollect
>>>>
>>>> | uarray collected |
>>>> uarray := UniformOrderedCollection new.
>>>> uarray add: 10.
>>>> uarray add: 20.
>>>> uarray add: (MissingValue discarding).
>>>> collected := uarray collect: [ :each | each ].
>>>> self assert: collected size equals: 2.
>>>>
>>>> testDo
>>>>
>>>> | res uarray |
>>>> uarray := UniformOrderedCollection new.
>>>> uarray add: 10.
>>>> uarray add: 20.
>>>> uarray add: (MissingValue discarding).
>>>> uarray add: 40.
>>>> res := 0.
>>>> uarray do: [ :each | res := res + each ].
>>>> self assert: res equals: 70.
>>>>
>>>>
>>>> testCollectDefaulting
>>>>
>>>> | uarray collected |
>>>> uarray := UniformOrderedCollection new.
>>>> uarray add: 10.
>>>> uarray add: 20.
>>>> uarray add: (MissingValue default: 33).
>>>> collected := uarray collect: [ :each | each ].
>>>> self assert: collected size equals: 3.
>>>> self assert: collected third equals: 33
>>>>
>>>>
>>>> I basically started to implement
>>>>
>>>>
>>>> do: aBlock
>>>> "Refer to the comment in Collection|do:."
>>>> 1 to: self size do:
>>>> [:index | (self at: index) toDo: aBlock on: self]
>>>>
>>>>
>>>>
>>>> collect: aBlock
>>>> "Evaluate aBlock with each of the receiver's elements as the argument.
>>>> Collect the resulting values into a collection like the receiver. Answer
>>>> the new collection."
>>>>
>>>> | newCollection |
>>>> newCollection := self species new.
>>>> self
>>>> do: [ :each | each toCollect: aBlock on: newCollection ].
>>>> ^ newCollection
>>>>
>>>>
>>>> and
>>>>
>>>> DiscardingValue >> toCollect: aBlock on: aCollection
>>>> "discard computation"
>>>> ^ self
>>>>
>>>>
>>>> Object >> toCollect: aBlock on: aCollection
>>>>
>>>> ^ aCollection add: (aBlock value: self)
>>>>
>>>>
>>>> So I imagine that you see the design and I wanted to get your point of view.
>>>>
>>>> --
>>>> Using Opera a kind of bad mail client but far better than thunderbird
>>>> _______________________________________________
>>>> Moose-dev mailing list
>>>> [hidden email]
>>>> https://www.list.inf.unibe.ch/listinfo/moose-dev
>>>
>>> --
>>> _,.;:~^~:;._,.;:~^~:;._,.;:~^~:;._,.;:~^~:;._,.;:
>>> Alexandre Bergel  http://www.bergel.eu
>>> ^~:;._,.;:~^~:;._,.;:~^~:;._,.;:~^~:;._,.;:~^~:;.
>>>
>>>
>>>
>>> _______________________________________________
>>> Moose-dev mailing list
>>> [hidden email]
>>> https://www.list.inf.unibe.ch/listinfo/moose-dev
>>
>> --
>> www.tudorgirba.com
>> www.feenk.com
>>
>> "If you interrupt the barber while he is cutting your hair,
>> you will end up with a messy haircut."
>>
>>
>
>
> --
> Using Opera's mail client: http://www.opera.com/mail/
> _______________________________________________
> Moose-dev mailing list
> [hidden email]
> https://www.list.inf.unibe.ch/listinfo/moose-dev

> On Dec 21, 2016, at 3:05 PM, stepharong <[hidden email]> wrote:
>
>
>
>> Hi Alex,
>>
>> Following the design proposed by Stef, in your case you would use a different collection.
>
> Doru I have multiple missingValue so that they embed their own strategy.
> Now I do not know for the scenario of alex.

>>
>> Cheers,
>> Doru
>>
>>
>>> On Dec 21, 2016, at 8:13 AM, Alexandre Bergel <[hidden email]> wrote:
>>>
>>> Hi Stef,
>>>
>>> You are raising an interesting point to discuss. This MissingValue is indeed better than having -1
>>> Something to keep in mind: it may be that one would like to focus on the missing value and not really the value.
>>>
>>> Consider:
>>>
>>>> testCollect
>>>>
>>>> | uarray collected |
>>>> uarray := UniformOrderedCollection new.
>>>> uarray add: 10.
>>>> uarray add: 20.
>>>> uarray add: (MissingValue discarding).
>>>> collected := uarray collect: [ :each | each ].
>>>> self assert: collected size equals: 2.
>>>
>>> It could well be that I would like to be able to query over the MissingValue.
>>> Can something like possible: uarray collect: #isMissing
>>> ?
>>>
>>> Cheers,
>>> Alexandre
>>>
>>>
>>>> On Dec 20, 2016, at 10:15 PM, stepharong <[hidden email]> wrote:
>>>>
>>>> Hi dear great OO designers
>>>>
>>>> Here is a little challenges for your brainy souls :)
>>>>
>>>> In Moose when we compute metrics it may happen than a tool (often external to pharo) does not compute a metrics
>>>> and when we request it in moose we check and often we return a not so good -1.
>>>>
>>>> I'm trying to brainstorm on a solution
>>>>
>>>> - first may be the simplest way is to not invoke a metrics when it is not computed. But it means that we should know it and that we should have a registration mechanism. After all this is probably the best solution.
>>>>
>>>> - Second we were thinking to use exception but when we have multiple entities missing one metrics.... I have serious doubts.
>>>>
>>>> - Second I was thinking about having the following behavior
>>>>
>>>> testCollect
>>>>
>>>> | uarray collected |
>>>> uarray := UniformOrderedCollection new.
>>>> uarray add: 10.
>>>> uarray add: 20.
>>>> uarray add: (MissingValue discarding).
>>>> collected := uarray collect: [ :each | each ].
>>>> self assert: collected size equals: 2.
>>>>
>>>> testDo
>>>>
>>>> | res uarray |
>>>> uarray := UniformOrderedCollection new.
>>>> uarray add: 10.
>>>> uarray add: 20.
>>>> uarray add: (MissingValue discarding).
>>>> uarray add: 40.
>>>> res := 0.
>>>> uarray do: [ :each | res := res + each ].
>>>> self assert: res equals: 70.
>>>>
>>>>
>>>> testCollectDefaulting
>>>>
>>>> | uarray collected |
>>>> uarray := UniformOrderedCollection new.
>>>> uarray add: 10.
>>>> uarray add: 20.
>>>> uarray add: (MissingValue default: 33).
>>>> collected := uarray collect: [ :each | each ].
>>>> self assert: collected size equals: 3.
>>>> self assert: collected third equals: 33
>>>>
>>>>
>>>> I basically started to implement
>>>>
>>>>
>>>> do: aBlock
>>>> "Refer to the comment in Collection|do:."
>>>> 1 to: self size do:
>>>> [:index | (self at: index) toDo: aBlock on: self]
>>>>
>>>>
>>>>
>>>> collect: aBlock
>>>> "Evaluate aBlock with each of the receiver's elements as the argument.
>>>> Collect the resulting values into a collection like the receiver. Answer
>>>> the new collection."
>>>>
>>>> | newCollection |
>>>> newCollection := self species new.
>>>> self
>>>> do: [ :each | each toCollect: aBlock on: newCollection ].
>>>> ^ newCollection
>>>>
>>>>
>>>> and
>>>>
>>>> DiscardingValue >> toCollect: aBlock on: aCollection
>>>> "discard computation"
>>>> ^ self
>>>>
>>>>
>>>> Object >> toCollect: aBlock on: aCollection
>>>>
>>>> ^ aCollection add: (aBlock value: self)
>>>>
>>>>
>>>> So I imagine that you see the design and I wanted to get your point of view.
>>>>
>>>> --
>>>> Using Opera a kind of bad mail client but far better than thunderbird
>>>> _______________________________________________
>>>> Moose-dev mailing list
>>>> [hidden email]
>>>> https://www.list.inf.unibe.ch/listinfo/moose-dev
>>>
>>> --
>>> _,.;:~^~:;._,.;:~^~:;._,.;:~^~:;._,.;:~^~:;._,.;:
>>> Alexandre Bergel  http://www.bergel.eu
>>> ^~:;._,.;:~^~:;._,.;:~^~:;._,.;:~^~:;._,.;:~^~:;.
>>>
>>>
>>>
>>> _______________________________________________
>>> Moose-dev mailing list
>>> [hidden email]
>>> https://www.list.inf.unibe.ch/listinfo/moose-dev
>>
>> --
>> www.tudorgirba.com
>> www.feenk.com
>>
>> "If you interrupt the barber while he is cutting your hair,
>> you will end up with a messy haircut."
>>
>>
>
>
> --
> Using Opera's mail client: http://www.opera.com/mail/

> Hi,
>
>> On Dec 21, 2016, at 3:05 PM, stepharong <[hidden email]> wrote:
>>
>>
>>
>>> Hi Alex,
>>>
>>> Following the design proposed by Stef, in your case you would use a  
>>> different collection.
>>
>> Doru I have multiple missingValue so that they embed their own strategy.
>> Now I do not know for the scenario of alex.
>
> Yes, yes. And that is great.
>
> It seemed to me that Alex wanted to find from the collection the  
> elements that have a MissingValue, and for that he wants to use  
> collect:. But, your collection collect: ignores the MissingValue. That  
> is why I thought that he can serve his case with another collection type.
>
> Cheers,
> Doru
>
>
>>>
>>> Cheers,
>>> Doru
>>>
>>>
>>>> On Dec 21, 2016, at 8:13 AM, Alexandre Bergel  
>>>> <[hidden email]> wrote:
>>>>
>>>> Hi Stef,
>>>>
>>>> You are raising an interesting point to discuss. This MissingValue is  
>>>> indeed better than having -1
>>>> Something to keep in mind: it may be that one would like to focus on  
>>>> the missing value and not really the value.
>>>>
>>>> Consider:
>>>>
>>>>> testCollect
>>>>>
>>>>> | uarray collected |
>>>>> uarray := UniformOrderedCollection new.
>>>>> uarray add: 10.
>>>>> uarray add: 20.
>>>>> uarray add: (MissingValue discarding).
>>>>> collected := uarray collect: [ :each | each ].
>>>>> self assert: collected size equals: 2.
>>>>
>>>> It could well be that I would like to be able to query over the  
>>>> MissingValue.
>>>> Can something like possible: uarray collect: #isMissing
>>>> ?
>>>>
>>>> Cheers,
>>>> Alexandre
>>>>
>>>>
>>>>> On Dec 20, 2016, at 10:15 PM, stepharong <[hidden email]> wrote:
>>>>>
>>>>> Hi dear great OO designers
>>>>>
>>>>> Here is a little challenges for your brainy souls :)
>>>>>
>>>>> In Moose when we compute metrics it may happen than a tool (often  
>>>>> external to pharo) does not compute a metrics
>>>>> and when we request it in moose we check and often we return a not  
>>>>> so good -1.
>>>>>
>>>>> I'm trying to brainstorm on a solution
>>>>>
>>>>> - first may be the simplest way is to not invoke a metrics when it  
>>>>> is not computed. But it means that we should know it and that we  
>>>>> should have a registration mechanism. After all this is probably the  
>>>>> best solution.
>>>>>
>>>>> - Second we were thinking to use exception but when we have multiple  
>>>>> entities missing one metrics.... I have serious doubts.
>>>>>
>>>>> - Second I was thinking about having the following behavior
>>>>>
>>>>> testCollect
>>>>>
>>>>> | uarray collected |
>>>>> uarray := UniformOrderedCollection new.
>>>>> uarray add: 10.
>>>>> uarray add: 20.
>>>>> uarray add: (MissingValue discarding).
>>>>> collected := uarray collect: [ :each | each ].
>>>>> self assert: collected size equals: 2.
>>>>>
>>>>> testDo
>>>>>
>>>>> | res uarray |
>>>>> uarray := UniformOrderedCollection new.
>>>>> uarray add: 10.
>>>>> uarray add: 20.
>>>>> uarray add: (MissingValue discarding).
>>>>> uarray add: 40.
>>>>> res := 0.
>>>>> uarray do: [ :each | res := res + each ].
>>>>> self assert: res equals: 70.
>>>>>
>>>>>
>>>>> testCollectDefaulting
>>>>>
>>>>> | uarray collected |
>>>>> uarray := UniformOrderedCollection new.
>>>>> uarray add: 10.
>>>>> uarray add: 20.
>>>>> uarray add: (MissingValue default: 33).
>>>>> collected := uarray collect: [ :each | each ].
>>>>> self assert: collected size equals: 3.
>>>>> self assert: collected third equals: 33
>>>>>
>>>>>
>>>>> I basically started to implement
>>>>>
>>>>>
>>>>> do: aBlock
>>>>> "Refer to the comment in Collection|do:."
>>>>> 1 to: self size do:
>>>>> [:index | (self at: index) toDo: aBlock on: self]
>>>>>
>>>>>
>>>>>
>>>>> collect: aBlock
>>>>> "Evaluate aBlock with each of the receiver's elements as the  
>>>>> argument.
>>>>> Collect the resulting values into a collection like the receiver.  
>>>>> Answer
>>>>> the new collection."
>>>>>
>>>>> | newCollection |
>>>>> newCollection := self species new.
>>>>> self
>>>>> do: [ :each | each toCollect: aBlock on: newCollection ].
>>>>> ^ newCollection
>>>>>
>>>>>
>>>>> and
>>>>>
>>>>> DiscardingValue >> toCollect: aBlock on: aCollection
>>>>> "discard computation"
>>>>> ^ self
>>>>>
>>>>>
>>>>> Object >> toCollect: aBlock on: aCollection
>>>>>
>>>>> ^ aCollection add: (aBlock value: self)
>>>>>
>>>>>
>>>>> So I imagine that you see the design and I wanted to get your point  
>>>>> of view.
>>>>>
>>>>> --
>>>>> Using Opera a kind of bad mail client but far better than thunderbird
>>>>> _______________________________________________
>>>>> Moose-dev mailing list
>>>>> [hidden email]
>>>>> https://www.list.inf.unibe.ch/listinfo/moose-dev
>>>>
>>>> --
>>>> _,.;:~^~:;._,.;:~^~:;._,.;:~^~:;._,.;:~^~:;._,.;:
>>>> Alexandre Bergel  http://www.bergel.eu
>>>> ^~:;._,.;:~^~:;._,.;:~^~:;._,.;:~^~:;._,.;:~^~:;.
>>>>
>>>>
>>>>
>>>> _______________________________________________
>>>> Moose-dev mailing list
>>>> [hidden email]
>>>> https://www.list.inf.unibe.ch/listinfo/moose-dev
>>>
>>> --
>>> www.tudorgirba.com
>>> www.feenk.com
>>>
>>> "If you interrupt the barber while he is cutting your hair,
>>> you will end up with a messy haircut."
>>>
>>>
>>
>>
>> --
>> Using Opera's mail client: http://www.opera.com/mail/
>
> --
> www.tudorgirba.com
> www.feenk.com
>
> “The smaller and more pervasive the hardware becomes, the more physical  
> the software gets."
>

>
>
> Yes I see. I will keep thinking about it.
>
>
> On Wed, 21 Dec 2016 20:58:26 +0100, Tudor Girba <[hidden email]>
> wrote:
>
>> Hi,
>>
>>> On Dec 21, 2016, at 3:05 PM, stepharong <[hidden email]> wrote:
>>>
>>>
>>>
>>>> Hi Alex,
>>>>
>>>> Following the design proposed by Stef, in your case you would use a
>>>> different collection.
>>>
>>>
>>> Doru I have multiple missingValue so that they embed their own strategy.
>>> Now I do not know for the scenario of alex.
>>
>>
>> Yes, yes. And that is great.
>>
>> It seemed to me that Alex wanted to find from the collection the elements
>> that have a MissingValue, and for that he wants to use collect:. But, your
>> collection collect: ignores the MissingValue. That is why I thought that he
>> can serve his case with another collection type.
>>
>> Cheers,
>> Doru
>>
>>
>>>>
>>>> Cheers,
>>>> Doru
>>>>
>>>>
>>>>> On Dec 21, 2016, at 8:13 AM, Alexandre Bergel <[hidden email]>
>>>>> wrote:
>>>>>
>>>>> Hi Stef,
>>>>>
>>>>> You are raising an interesting point to discuss. This MissingValue is
>>>>> indeed better than having -1
>>>>> Something to keep in mind: it may be that one would like to focus on
>>>>> the missing value and not really the value.
>>>>>
>>>>> Consider:
>>>>>
>>>>>> testCollect
>>>>>>
>>>>>>         | uarray collected |
>>>>>>         uarray := UniformOrderedCollection new.
>>>>>>         uarray add: 10.
>>>>>>         uarray add: 20.
>>>>>>         uarray add: (MissingValue discarding).
>>>>>>         collected := uarray collect: [ :each | each ].
>>>>>>         self assert: collected size equals: 2.
>>>>>
>>>>>
>>>>> It could well be that I would like to be able to query over the
>>>>> MissingValue.
>>>>> Can something like possible: uarray collect: #isMissing
>>>>> ?
>>>>>
>>>>> Cheers,
>>>>> Alexandre
>>>>>
>>>>>
>>>>>> On Dec 20, 2016, at 10:15 PM, stepharong <[hidden email]> wrote:
>>>>>>
>>>>>> Hi dear great OO designers
>>>>>>
>>>>>> Here is a little challenges for your brainy souls :)
>>>>>>
>>>>>> In Moose when we compute metrics it may happen than a tool (often
>>>>>> external to pharo) does not compute a metrics
>>>>>> and when we request it in moose we check and often we return a not so
>>>>>> good -1.
>>>>>>
>>>>>> I'm trying to brainstorm on a solution
>>>>>>
>>>>>> - first may be the simplest way is to not invoke a metrics when it is
>>>>>> not computed. But it means that we should know it and that we should have a
>>>>>> registration mechanism. After all this is probably the best solution.
>>>>>>
>>>>>> - Second we were thinking to use exception but when we have multiple
>>>>>> entities missing one metrics.... I have serious doubts.
>>>>>>
>>>>>> - Second I was thinking about having the following behavior
>>>>>>
>>>>>> testCollect
>>>>>>
>>>>>>         | uarray collected |
>>>>>>         uarray := UniformOrderedCollection new.
>>>>>>         uarray add: 10.
>>>>>>         uarray add: 20.
>>>>>>         uarray add: (MissingValue discarding).
>>>>>>         collected := uarray collect: [ :each | each ].
>>>>>>         self assert: collected size equals: 2.
>>>>>>
>>>>>> testDo
>>>>>>
>>>>>>         | res uarray |
>>>>>>         uarray := UniformOrderedCollection new.
>>>>>>         uarray add: 10.
>>>>>>         uarray add: 20.
>>>>>>         uarray add: (MissingValue discarding).
>>>>>>         uarray add: 40.
>>>>>>         res := 0.
>>>>>>         uarray do: [ :each | res := res + each ].
>>>>>>         self assert: res equals: 70.
>>>>>>
>>>>>>
>>>>>> testCollectDefaulting
>>>>>>
>>>>>>         | uarray collected |
>>>>>>         uarray := UniformOrderedCollection new.
>>>>>>         uarray add: 10.
>>>>>>         uarray add: 20.
>>>>>>         uarray add: (MissingValue default: 33).
>>>>>>         collected := uarray collect: [ :each | each ].
>>>>>>         self assert: collected size equals: 3.
>>>>>>         self assert: collected third equals: 33
>>>>>>
>>>>>>
>>>>>> I basically started to implement
>>>>>>
>>>>>>
>>>>>> do: aBlock
>>>>>>         "Refer to the comment in Collection|do:."
>>>>>>         1 to: self size do:
>>>>>>                 [:index | (self at: index) toDo: aBlock on: self]
>>>>>>
>>>>>>
>>>>>>
>>>>>> collect: aBlock
>>>>>>         "Evaluate aBlock with each of the receiver's elements as the
>>>>>> argument.
>>>>>>         Collect the resulting values into a collection like the
>>>>>> receiver. Answer
>>>>>>         the new collection."
>>>>>>
>>>>>>         | newCollection |
>>>>>>         newCollection := self species new.
>>>>>>         self
>>>>>>                 do: [ :each | each toCollect: aBlock on: newCollection
>>>>>> ].
>>>>>>         ^ newCollection
>>>>>>
>>>>>>
>>>>>> and
>>>>>>
>>>>>> DiscardingValue >> toCollect: aBlock on: aCollection
>>>>>>         "discard computation"
>>>>>>         ^ self
>>>>>>
>>>>>>
>>>>>> Object >> toCollect: aBlock on: aCollection
>>>>>>
>>>>>>         ^ aCollection add: (aBlock value: self)
>>>>>>
>>>>>>
>>>>>> So I imagine that you see the design and I wanted to get your point of
>>>>>> view.
>>>>>>
>>>>>> --
>>>>>> Using Opera a kind of bad mail client but far better than thunderbird
>>>>>> _______________________________________________
>>>>>> Moose-dev mailing list
>>>>>> [hidden email]
>>>>>> https://www.list.inf.unibe.ch/listinfo/moose-dev
>>>>>
>>>>>
>>>>> --
>>>>> _,.;:~^~:;._,.;:~^~:;._,.;:~^~:;._,.;:~^~:;._,.;:
>>>>> Alexandre Bergel  http://www.bergel.eu
>>>>> ^~:;._,.;:~^~:;._,.;:~^~:;._,.;:~^~:;._,.;:~^~:;.
>>>>>
>>>>>
>>>>>
>>>>> _______________________________________________
>>>>> Moose-dev mailing list
>>>>> [hidden email]
>>>>> https://www.list.inf.unibe.ch/listinfo/moose-dev
>>>>
>>>>
>>>> --
>>>> www.tudorgirba.com
>>>> www.feenk.com
>>>>
>>>> "If you interrupt the barber while he is cutting your hair,
>>>> you will end up with a messy haircut."
>>>>
>>>>
>>>
>>>
>>> --
>>> Using Opera's mail client: http://www.opera.com/mail/
>>
>>
>> --
>> www.tudorgirba.com
>> www.feenk.com
>>
>> “The smaller and more pervasive the hardware becomes, the more physical
>> the software gets."
>>
>
>
> --
> Using Opera's mail client: http://www.opera.com/mail/
> _______________________________________________
> Moose-dev mailing list
> [hidden email]
> https://www.list.inf.unibe.ch/listinfo/moose-dev