It would be great if algebrick could be used for defining the data comming from external services over REST and others.

Usually, one doesn't care about all the data that come from the REST, and it would cause more harm than benefits to try doing that. The idea is to define only the fields
that we care about in our code-base and don't care about the rest that much.

Let's say, I get this hash from the REST:

p = {"person": {"name":"Petr", "created_at":"2013-12-28"}}

I care only about the name, so instead of having to define all the fields that might occur (and breaking immediately, when something new is added), I want to ignore the rest of store that in some additional field:

Person = Algebrick.type do
  fields name: "Petr"
  ignore_other_fields
end

or

Person = Algebrick.type do
  fields name: "Petr"
  store_other_fields :others
end

person = Person[p]
person[:name] # => "Petr"
person[:others][:created_at] # => "2013-12-28"

Hi,

Really like the look of this library, though I'm struggling to use or define a/the list type. I tried defining my own and I've tried using the one in lib/algebrick/types.rb - I'm not even sure I should be calling that directly. I'm at a bit of a loss. Is there an example for this somewhere, or do you know of a library using it? (real world examples are always best:)

Any help or insight would be much appreciated.

Regards,
iain

For better code orientation, it would be nice to have the code placed in more smaller files, than one big algebrick.rb. The same for tests. What do you think?

Envelope = Algebrick.type do
  fields! request_id: Integer,
            sender_id: String,
            receiver_id: type { variants String, AnyExecutor = atom, UnknownWorld = atom },
            message: type { variants Request, Response }

With, Envolope.to_s it produces NoName, where it could descibe, the message as the variant of other types

I want to define that person has more phone numbers, something like:

Person = Algebrick.type do
  fields name: String
         phone_numbers: TypedArray[String]
end

I tent to like this gem more and more every day:) I would like to use that for loading hashes from REST APIs (possibly with integration with apipie-rails later) and others

Let's say I have a hash:

petr_data = { name: "Petr", sex: "male" }
ada_data  = { name: "Ada", sex: "female" } 

I would like to do something like this:

Person = Algebrick.type do
    fields name: String,
             sex: [:male, :female]
end

people = [Person[petr_data], Person[ada_data]]

if people.any? { |person| person[:sex] == :male } ||
   people.any? { |person| person[:sex] == :female }
  puts "Congrats, your code is coeducated"
end

Maybe the :male and :female could be defined with separate types, and include there pattern matching:

Gender = Algebrick.type do |gender|
   variants gender::Male = atom, gender::Female = atom
   match do |value|
       case value
       when "male", :male
          gender::Male
       when "female", :female
          gender::Female 
       end
   end
end
Person = Algebrick.type do
    fields name: String,
             sex: Gender
end

So the match would provide a way how to typecast the values.