Ruby has is a dynamic language, it has no types, why would we care?
View Slide
Nikita ShilnikovMe
I work on
Typed Ruby
There are no typesin Ruby
Everything is an object
Objects interact viamessage passing
1 + 2
1:+,2message target
1.methods
=> [:%, :&, :*, :+, :-, :/, :, :^, :|, :~, :[email protected], :**, :<=>, :<:>>, :<=, :>=, :==, :===, :[], :inspect, :size, :succ, :to_int, :to_s,:to_i, :to_f, :next, :div, :upto, :chr, :ord, :coerce, :divmod, :fdiv,:modulo, :remainder, :abs, :magnitude, :integer?, :floor, :ceil,:round, :truncate, :odd?, :even?, :downto, :times, :pred, :bit_length,:digits, :to_r, :numerator, :denominator, :rationalize, :gcd, :lcm,:gcdlcm, :[email protected], :eql?, :singleton_method_added, :i, :real?, :zero?,:nonzero?, :finite?, :infinite?, :step, :positive?, :negative?, :quo,:arg, :rectangular, :rect, :polar, :real, :imaginary, :imag, :abs2,:angle, :phase, :conjugate, :conj, :to_c, :between?, :clamp,:instance_of?, :kind_of?, :is_a?, :tap, :public_send,:remove_instance_variable, :public_method, :singleton_method,:instance_variable_set, :define_singleton_method, :method, :extend,:to_enum, :enum_for, :=~, :!~, :respond_to?, :freeze, :object_id,:send, :display, :nil?, :hash, :class, :singleton_class, :clone, :dup,:itself, :taint, :tainted?, :untaint, :untrust, :untrusted?, :trust,:frozen?, :methods, :singleton_methods, :protected_methods,:private_methods, :public_methods, :instance_variable_get,:instance_variables, :instance_variable_defined?, :!, :!=,:__send__, :equal?, :instance_eval, :instance_exec, :__id__]
Duck typing
a + b
a.respond_to?(:+)
Consequences
foo.size # => 8
A real world example
name = params[:name]
name = params[:name]String
name # => true
But true is not a String!
name.camelize
new_user = User.new(params.permit(:name))new_user.name # => ?
"t"
Problems1. Using models for coercion is questionable.2. Coercion logic is opaque.3. Types are defined by database columns.4. Unhappy paths end with an error (better) or adata corruption (worse).
Duck typing is unreliablewhen working with data
What is a type?
What is a type?1. A category of people or things having commoncharacteristics.2. A person or thing exemplifying the ideal ordefining characteristics of something(prototype).3. Characters or letters that are printed or shownon a screen.
A category of people or things havingcommon characteristics1. Natural numbers (1, 2, 3, 4, ...).2. Emojis ( ...).3. Vertebrates (dog, cat, horse, ...).
Types in programmingAlso called data types.Play a major role in statically typedlanguages.
Types in staticlanguages
–Haskell Wiki“Types are how youdescribe the data yourprogram will work with.”
–Type-Driven Development with Idris“Types are a means ofclassifying (data) values.”
data Planet = Earth
data Planet = Earthkeyword
data Planet = Earthtype name
data Planet = Earthvalue
data Planet = Earth | Mars | ...values
isEarth Earth = TrueisEarth x = False
def earth?(planet)planet == :earthend
def earth?(planet)planet.public_send(:==, :earth)end
earth?(:earth) # => trueearth?(:mars) # => falseearth?(:sun) # => falseearth?(1) # => false
isEarth 1
isEarth :: Planet -> Bool
1. Early sanity-check, the compiler will checkyour code for consistency.2. Advanced compilers can check a program forcorrectness.3. Better semantics and docs.4. Better introspection/IDE integration.5. A lot of performance optimizations can bedone during the compile phase.Pros:
1. Compilation takes time.2. Types require more typing making code moreverbose and less flexible.Cons:
Statically typedlanguages havetype inference
val firstName = "Adam"
Dynamically typedlanguages havetype annotations
def is_earth(planet: Planet):...
Types in Ruby
Duck typing hasnothing to do withtypes
Duck typing isuseless fordescribing data
Applications areuseless withoutdata
dry-validation
schemaraw input valid dataapp DBerrors
outer worldapplication
CreateUserSchema = Dry::Validation.JSON dorequired(:name).filled(:str?)end
CreateUserSchema.call(params)
CreateUserSchema.call('name' => 'John').output# => { name: 'John' }
CreateUserSchema.call('name' => true).output# => { name: ["must be a string"] }
something.blank?
dry-types
—a type system built for coercion and datavalidation;—formerly known as dry-data;—initially was created as a replacement forvirtus;—is a direct dependency of dry-validation,ROM, and hanami-model.dry-types
Adding types toRuby
module Typesinclude Dry::Types.moduleend
int = Types::Strict::Intint[3] # => 3
int = Types::Strict::Intint[3] # => 3int['3']# => '3' violates constraints# (type?(Integer, '3') failed)
int = Types::Coercible::Intint[3] # => 3int['3'] # => 3
Integer('3')nil.to_i # => 0Integer(nil) # => TypeError''.to_i # => 0Integer('') # => ArgumentError
Type constraints
Types are like sets
Types::Age = Types::Strict::Int.constrained(gteq: 18)
Case equality
case valuewhen Types::Strict::Int then :numberwhen Types::Strict::String then :strend
Types have algebra*
Types::Strict::Int | Types::Strict::String
dry-struct
class User < Dry::Structattribute :name, Types::Strict::Stringattribute :age, Types::Ageend
Structs are meant tobe valid
module ProfileEventsclass PasswordChanged < Dry::Structattribute :user_id, Types::UUIDattribute :password, Types::Passwordendclass EmailChanged < Dry::Structattribute :user_id, Types::UUIDattribute :email, Types::EmailendUpdated = PasswordChanged | EmailChangedend
Custom types
module Typesinclude Dry::Types.moduleendTypes.Instance(Customer)Types.Constructor(Geopoint) { |lon, lat|"POINT (#{ lat } #{ lon })"}Types.Constant(:only_allowed)
What’s inside?
Types are values
Types::Int.constrained(gteq: 18) == Types::Int.constrained(gteq: 18)
age = Types::Strict::Int.constrained(gteq: 18)types = {age => :age}types[Types::Strict::Int.constrained(gteq: 18)] # => :age
schema doattribute :company, Types::Stringattribute :license, Types::PG::JSONBend
where { license.contain(enabled: true) }# WHERE "companies"."license" @> '{"enabled":true}'::jsonb)
TypeExtensions.register(JSONB) dodef contain(type, expr, value)sql = wrap(expr).contains(value)Attribute[SQL::Types::Bool].meta(sql_expr: sql)endend
ROM 4.0 is out
Types have metadata
first_name = Types::Strict::String.constrained(min_size: 3)last_name = Types::Strict::String.constrained(min_size: 3)
first_name = Types::Strict::String.constrained(min_size: 3).meta(name: 'first_name')last_name = Types::Strict::String.constrained(min_size: 3).meta(name: 'last_name')
Types have ASTs
Types::Strict::String.constrained(min_size: 3)# => #primitive=String options={} meta={}>options={:rule=>#rules=[#Module(Dry::Logic::Predicates::Methods)#type?>options={:args=>[String]}>, #predicate=#Module(Dry::Logic::Predicates::Methods)#min_size?>options={:args=>[3]}>] options={}>}rule=#rules=[#Module(Dry::Logic::Predicates::Methods)#type?>options={:args=>[String]}>, #predicate=#Module(Dry::Logic::Predicates::Methods)#min_size?>options={:args=>[3]}>] options={}> meta={}>
int = Types::Strict::Intint.to_ast[:constrained,[[:definition, [Integer, {}]],[:predicate,[:type?,[[:type, Integer],[:input, Undefined]]]], {}]]
require 'dry/types/compiler'compiler = Dry::Types::Compiler.new(Dry::Types)int = Types::Strict::Intint == compiler.(int.to_ast)
Age (Int >= 18) rand(50) + 18
—data generators;—serializers;—data transformers;—auto-docs;—???
Types make life easier
Types make life easierSo use them
Recap— Duck typing is neither about ducks nor typing.— Types are sets of possible values that shapethe data.— In dry-types types are ordinary objects thatcan be build and composed.— Types can even be decomposed allowing youto build new abstractions on top of them.
Do not use .blank?
It’s not about Haskell
1.0 is almost there
Linksdry-rb.org/gems/dry-typesgithub.com/dry-rb/dry-typesdiscourse.dry-rb.orggitter.im/dry-rb/chat
Thank you!github.com/flash-gordon @NikitaShilnikov
flashgordon
hiro_y
gpsnmeajp
dicoding
ivargrimstad
terukinakano
gennei
n1215
mrstsgk
sh1n0g1
javiergs
ryamakuchi
cocoeyes02
bkeepers
philhawksworth
tammielis
lauravandoore
keithpitt
lara
62gerente
maltzj
eileencodes
rmw
holman
jlugia