├── Array ├── amp.cr ├── at.cr ├── braeq.cr ├── buffer.cr ├── build.cr ├── clear.cr ├── clone.cr ├── cmp.cr ├── compact.cr ├── concat.cr ├── count.cr ├── delete.cr ├── delete_at.cr ├── delete_if.cr ├── dup.cr ├── each.cr ├── each_index.cr ├── empty.cr ├── eq.cr ├── equals.cr ├── fill.cr ├── first.cr ├── hash.cr ├── insert.cr ├── inspect.cr ├── last.cr ├── last_q.cr ├── length.cr ├── map.cr ├── map_with_index.cr ├── new1.cr ├── pipe.cr ├── plus.cr ├── pop.cr ├── pop_q.cr ├── product.cr ├── push.cr ├── push_.cr ├── reject.cr ├── replace.cr ├── reverse.cr ├── reverse_each.cr ├── rindex.cr ├── sample.cr ├── select.cr ├── shift.cr ├── shift_q.cr ├── shuffle.cr ├── size.cr ├── sort.cr ├── sort_by.cr ├── square_brackets.cr ├── square_brackets_q.cr ├── swap.cr ├── to_a.cr ├── to_s.cr ├── transpose.cr ├── uniq.cr ├── unshift.cr ├── update.cr ├── values_at.cr └── zip.cr ├── Base64 ├── decode.cr ├── encode.cr ├── strict_encode.cr └── urlsafe_encode.cr ├── BitArray ├── bracket.cr ├── bracket_eq.cr ├── invert.cr ├── new.cr └── toggle.cr ├── Bool ├── and.cr ├── eqeq.cr ├── exclamation.cr ├── not_eq.cr └── or.cr ├── CSV ├── build.cr ├── each_row.cr └── parse.cr ├── Char ├── alpha.cr ├── alphanumeric.cr ├── bytes.cr ├── comparison.cr ├── control.cr ├── digit.cr ├── downcase.cr ├── eq.cr ├── greater.cr ├── less.cr ├── less_eq.cr ├── minus.cr ├── not_eq.cr ├── pred.cr ├── succ.cr ├── upcase.cr └── whitespace.cr ├── Deque ├── at.cr ├── bracket.cr ├── bracket_q.cr ├── clear.cr ├── clone.cr ├── concat.cr ├── delete_at.cr ├── dup.cr ├── each.cr ├── each_index.cr ├── empty.cr ├── eqeq.cr ├── equals.cr ├── first.cr ├── first_q.cr ├── insert.cr ├── last.cr ├── last_q.cr ├── ltlt.cr ├── new.cr ├── plus.cr ├── pop.cr ├── pop_q.cr ├── push.cr ├── reverse_each.cr ├── rotate.cr ├── shift.cr ├── shift_q.cr ├── size.cr ├── swap.cr ├── to_a.cr ├── to_s.cr └── unshift.cr ├── ENV ├── at.cr ├── at_eq.cr ├── at_q.cr ├── clear.cr ├── delete.cr ├── each.cr ├── fetch.cr ├── has_key.cr ├── keys.cr └── values.cr ├── Enum ├── and.cr ├── comp.cr ├── enum1.cr ├── enum2.cr ├── eq.cr ├── from_value.cr ├── from_value_q.cr ├── hash.cr ├── includes.cr ├── names.cr ├── parse.cr ├── parse_q.cr ├── pipe.cr ├── plus.cr ├── to_f32.cr ├── to_f64.cr ├── to_i.cr ├── to_i16.cr ├── to_i32.cr ├── to_i64.cr ├── to_i8.cr ├── to_s.cr ├── to_u16.cr ├── to_u32.cr ├── to_u64.cr ├── to_u8.cr ├── values.cr └── xor.cr ├── Enumerable ├── all_q.cr ├── any_q.cr ├── compact_map.cr ├── count.cr ├── cycle.cr ├── each.cr ├── each_cons.cr ├── each_slice.cr ├── each_with_index.cr ├── each_with_object.cr ├── find.cr ├── first.cr ├── first_q.cr ├── flat_map.cr ├── grep.cr ├── group_by.cr ├── in_group_of.cr ├── includes.cr ├── index.cr ├── index_by.cr ├── join.cr ├── map.cr ├── map_with_index.cr ├── max.cr ├── max_by.cr ├── max_of ├── max_q.cr ├── min.cr ├── min_by.cr ├── min_of.cr ├── min_of_q.cr ├── min_q.cr ├── minmax.cr ├── minmax_by.cr ├── minmax_of.cr ├── none_q.cr ├── one.cr ├── partition.cr ├── reject.cr ├── select.cr ├── size.cr ├── skip.cr ├── skip_while.cr ├── sum.cr ├── take.cr ├── take_while.cr ├── to_a.cr ├── to_h.cr └── to_set.cr ├── Exception ├── backtrace.cr ├── cause.cr ├── inspect_with_backtrace.cr ├── message.cr └── to_s.cr ├── Float ├── compare.cr ├── days.cr ├── fdiv.cr ├── finite.cr ├── hours.cr ├── infinite.cr ├── milliseconds.cr ├── minutes.cr ├── modulo.cr ├── nan.cr ├── percent.cr ├── remainder.cr └── seconds.cr ├── HTML └── escape.cr ├── Hash ├── all_q.cr ├── any_q.cr ├── br.cr ├── br_eq.cr ├── br_q.cr ├── clear.cr ├── clone.cr ├── delete.cr ├── delete_if.cr ├── dup.cr ├── each.cr ├── each_key.cr ├── each_value.cr ├── each_with_index.cr ├── each_with_object.cr ├── empty.cr ├── eq.cr ├── fetch.cr ├── first.cr ├── first_key.cr ├── first_value_q.cr ├── has_key.cr ├── hash.cr ├── invert.cr ├── key.cr ├── key_index.cr ├── key_q.cr ├── keys.cr ├── map.cr ├── merge.cr ├── reduce.cr ├── reject.cr ├── select.cr ├── shift.cr ├── size.cr ├── to_a.cr ├── to_s.cr ├── values.cr └── values_at.cr ├── IniFile └── load.cr ├── Int ├── abs.cr ├── amp.cr ├── bit.cr ├── ceil.cr ├── chr.cr ├── day.cr ├── days.cr ├── divide.cr ├── divisible_by.cr ├── down_to.cr ├── even.cr ├── gcd.cr ├── hour.cr ├── hours.cr ├── lcm.cr ├── lshift.cr ├── millisecond.cr ├── milliseconds.cr ├── minus.cr ├── minute.cr ├── minutes.cr ├── modulo.cr ├── month.cr ├── months.cr ├── multiply.cr ├── odd.cr ├── percent.cr ├── plus.cr ├── power.cr ├── pred.cr ├── rshift.cr ├── second.cr ├── seconds.cr ├── succ.cr ├── times.cr ├── to.cr ├── upto.cr ├── week.cr ├── weeks.cr ├── year.cr └── years.cr ├── Markdown └── to_html.cr ├── Nil ├── eqeq.cr ├── hash.cr ├── inspect.cr ├── nil_q.cr ├── not.cr ├── object_id.cr ├── same.cr ├── to_s.cr └── try.cr ├── README.md ├── Range ├── begin.cr ├── covers.cr ├── cycle.cr ├── each.cr ├── end.cr ├── eqeqeq.cr ├── excludes_end.cr ├── exclusive.cr ├── includes.cr ├── new.cr ├── reverse_each.cr ├── step.cr └── sum.cr ├── Regex ├── eq.cr ├── eq_tilde.cr ├── error.cr ├── escape.cr ├── inspect.cr ├── match.cr ├── name_table.cr ├── options.cr ├── plus.cr ├── source.cr ├── to_s.cr └── union.cr ├── SecureRandom ├── base64.cr ├── hex.cr ├── random_bytes.cr ├── urlsafe_base64.cr └── uuid.cr ├── Set ├── add.cr ├── and.cr ├── clear.cr ├── clone.cr ├── delete.cr ├── each.cr ├── empty.cr ├── eqeq.cr ├── includes.cr ├── intersects.cr ├── merge.cr ├── minus.cr ├── new.cr ├── proper_subset.cr ├── proper_superset.cr ├── sdiff.cr ├── size.cr ├── subset.cr ├── subtract.cr ├── superset.cr ├── to_a.cr └── union.cr ├── SimpleHash ├── bracket.cr ├── delete.cr ├── dup.cr ├── each.cr ├── each_key.cr ├── each_value.cr ├── each_with_object.cr ├── fetch.cr ├── has_key.cr ├── keys.cr ├── new.cr ├── reject.cr ├── select.cr ├── size.cr └── values.cr ├── String ├── ascii_only.cr ├── bytes.cr ├── camelcase.cr ├── capitalize.cr ├── char_at.cr ├── chars.cr ├── chomp.cr ├── chop.cr ├── clone.cr ├── codepoint_at.cr ├── codepoints.cr ├── compare.cr ├── count.cr ├── delete.cr ├── downcase.cr ├── dump.cr ├── each_byte.cr ├── each_char.cr ├── each_codepoint.cr ├── each_line.cr ├── empty.cr ├── ends_with.cr ├── eq.cr ├── eqc.cr ├── gsub.cr ├── includes.cr ├── index.cr ├── insert.cr ├── lines.cr ├── ljust.cr ├── lstrip.cr ├── lteqgt.cr ├── multiply.cr ├── percent.cr ├── plus.cr ├── reverse.cr ├── rindex.cr ├── rjust.cr ├── rstrip.cr ├── scan.cr ├── size.cr ├── square_bracket.cr ├── square_bracket_q.cr ├── squeeze.cr ├── starts_with.cr ├── strip.cr ├── sub.cr ├── succ.cr ├── to_f.cr ├── to_i.cr ├── to_slice.cr ├── tr.cr ├── underscore.cr └── upcase.cr ├── StringPool └── get.cr ├── StringScanner ├── bracket.cr ├── check.cr ├── eos.cr ├── offset.cr ├── peek.cr ├── reset.cr ├── rest.cr ├── scan.cr ├── skip.cr └── string.cr ├── Struct ├── eqeq.cr ├── hash.cr └── inspect.cr ├── Symbol ├── clone.cr ├── compare.cr ├── eq.cr ├── hash.cr ├── inspect.cr ├── not_eq.cr ├── to_i.cr └── to_s.cr ├── Time ├── add_ticks.cr ├── at_beginning_of_day.cr ├── at_beginning_of_hour.cr ├── at_beginning_of_minute.cr ├── at_beginning_of_month.cr ├── at_beginning_of_quarter.cr ├── at_beginning_of_semester.cr ├── at_beginning_of_week.cr ├── at_beginning_of_year.cr ├── at_end_of_day.cr ├── at_end_of_hour.cr ├── at_end_of_minute.cr ├── at_end_of_month.cr ├── at_end_of_quarter.cr ├── at_end_of_semester.cr ├── at_end_of_week.cr ├── at_end_of_year.cr ├── at_midday.cr ├── cmp.cr ├── date.cr ├── day_of_week.cr ├── day_of_year.cr ├── days_in_month.cr ├── epoch.cr ├── epoch_ms.cr ├── friday.cr ├── hour.cr ├── kind.cr ├── leap_year.cr ├── local.cr ├── local_offset_in_minutes.cr ├── millisecond.cr ├── minus.cr ├── minute.cr ├── monday.cr ├── month.cr ├── now.cr ├── parse.cr ├── plus.cr ├── saturday.cr ├── second.cr ├── sunday.cr ├── thursday.cr ├── to_utc.cr ├── tuesday.cr ├── utc.cr ├── utc_now.cr ├── wednesday.cr └── year.cr ├── Tuple ├── at.cr ├── clone.cr ├── compare.cr ├── each.cr ├── eq.cr ├── eqq.cr ├── first.cr ├── first_q.cr ├── from.cr ├── hash.cr ├── inspect.cr ├── last.cr ├── map.cr ├── new.cr ├── plus.cr ├── reverse.cr ├── reverse_each.cr ├── size.cr └── square_bracket.cr ├── URI ├── eq.cr ├── escape.cr ├── fragment.cr ├── full_path.cr ├── hash.cr ├── host.cr ├── host_eq.cr ├── new.cr ├── opaque.cr ├── opaque_eq.cr ├── parse.cr ├── password.cr ├── password_eq.cr ├── path.cr ├── path_eq.cr ├── port.cr ├── port_eq.cr ├── query.cr ├── query_eq.cr ├── reserved.cr ├── scheme.cr ├── scheme_eq.cr ├── to_s.cr ├── unescape.cr ├── unreserved.cr ├── user.cr ├── user_eq.cr └── userinfo.cr ├── Union ├── new.cr └── nilable.cr ├── XML ├── escape.cr ├── parse.cr └── parse_html.cr └── toplevels └── pp.cr /Array/amp.cr: -------------------------------------------------------------------------------- 1 | hoges = ["hoge", "hige", "hage"] 2 | pp hoges & ["hoge", "hage", "hoo"] 3 | 4 | # => hoges & ["hoge", "hage", "hoo"] = ["hoge", "hage"] 5 | -------------------------------------------------------------------------------- /Array/at.cr: -------------------------------------------------------------------------------- 1 | hoges = %w(hoge hige hage) 2 | pp hoges.at(1) 3 | pp hoges.at(-1) 4 | hoges.at(1) { |e1|pp e1 } 5 | hoges.at(5) { |e2|pp e2 } 6 | 7 | # hoges.at(1) = "hige" 8 | # hoges.at(-1) = "hage" 9 | # e2 = nil 10 | -------------------------------------------------------------------------------- /Array/braeq.cr: -------------------------------------------------------------------------------- 1 | hoges = %w(hoge hige hage) 2 | hoges[0] = "@hoge" 3 | pp hoges 4 | hoges[-1] = "@hage" 5 | pp hoges 6 | 7 | # => hoges = ["@hoge", "hige", "hage"] 8 | # => hoges = ["@hoge", "hige", "@hage"] -------------------------------------------------------------------------------- /Array/buffer.cr: -------------------------------------------------------------------------------- 1 | hoges = %w(hoge hige hage) 2 | pp hoges.buffer 3 | -------------------------------------------------------------------------------- /Array/build.cr: -------------------------------------------------------------------------------- 1 | size = 10 2 | ary = Array(Int32).build(size) do |buffer| 3 | size.times { |i|buffer[i] = i+2 } 4 | size 5 | end 6 | p ary 7 | 8 | # => [2, 3, 4, 5, 6, 7, 8, 9, 10, 11] 9 | -------------------------------------------------------------------------------- /Array/clear.cr: -------------------------------------------------------------------------------- 1 | hoges = %w(hoge hige hage) 2 | pp hoges 3 | hoges.clear 4 | pp hoges 5 | 6 | # hoges = ["hoge", "hige", "hage"] 7 | # hoges = [] 8 | -------------------------------------------------------------------------------- /Array/clone.cr: -------------------------------------------------------------------------------- 1 | hoges = %w(hoge hige hage) 2 | hoges_clone = hoges.clone 3 | pp hoges == hoges_clone 4 | hoges_clone << "hege" 5 | pp hoges == hoges_clone 6 | pp hoges_clone 7 | 8 | # => hoges == hoges_clone = true 9 | # => hoges == hoges_clone = false 10 | # => hoges_clone = ["hoge", "hige", "hage", "hege"] -------------------------------------------------------------------------------- /Array/cmp.cr: -------------------------------------------------------------------------------- 1 | hoges = ["hoge", "hige", "hage"] 2 | pp hoges <=> ["hoge", "hige", "hage"] 3 | pp hoges <=> ["hage", "hige", "hage"] 4 | pp hoges <=> ["hage", "hige", "hage", "hege"] 5 | pp hoges <=> ["hpge", "hige"] 6 | 7 | # => hoges <=> ["hoge", "hige", "hage"] = 0 8 | # => hoges <=> ["hage", "hige", "hage"] = 1 9 | # => hoges <=> ["hage", "hige", "hage", "hege"] = 1 10 | # => hoges <=> ["hpge", "hige"] = -1 -------------------------------------------------------------------------------- /Array/compact.cr: -------------------------------------------------------------------------------- 1 | ary = [1,2,nil] 2 | compact_ary = ary.compact 3 | pp compact_ary 4 | ary2 = [3,4,nil] 5 | compact_ary2 = ary.compact(ary2) 6 | pp compact_ary2 7 | pp ary2 8 | # => compact_ary = [1, 2] 9 | # => compact_ary2 = [1, 2, nil] 10 | # => ary2 = [3, 4, nil, 1, 2] 11 | # Array#compact(array)は 12 | # selfには影響を及ぼさず、 13 | # 引数のarrayの末尾にcompact化したselfを追加する 14 | # 副作用のあるメソッドのように見える。 15 | # メソッド名と処理内容がアンマッチに見えるが意図は不明 16 | -------------------------------------------------------------------------------- /Array/concat.cr: -------------------------------------------------------------------------------- 1 | class StepTwo 2 | include Enumerable(Int32) 3 | 4 | def initialize(limit) 5 | @limit = limit 6 | end 7 | 8 | def each 9 | i = 0 10 | loop { 11 | yield i 12 | i += 2 13 | break if i > @limit 14 | } 15 | end 16 | end 17 | 18 | ary = [1,2,3] 19 | pp [1,2,3].concat([4,5,6]) 20 | pp [1,2,3].concat(StepTwo.new(10)) 21 | pp [1,2,3].concat(StepTwo.new(20)) 22 | 23 | # => [1, 2, 3].concat([4, 5, 6]) = [1, 2, 3, 4, 5, 6] 24 | # => [1, 2, 3].concat(StepTwo.new(10)) = [1, 2, 3, 0, 2, 4, 6, 8, 10] 25 | # => [1, 2, 3].concat(StepTwo.new(20)) = [1, 2, 3, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20] 26 | -------------------------------------------------------------------------------- /Array/count.cr: -------------------------------------------------------------------------------- 1 | pp [1,2,3].count 2 | pp [1,2,3,4,5].count 3 | 4 | # => [1, 2, 3].count = 3 5 | # => [1, 2, 3, 4, 5].count = 5 -------------------------------------------------------------------------------- /Array/delete.cr: -------------------------------------------------------------------------------- 1 | ary = [1,2,3,4,5] 2 | pp ary 3 | pp ary.delete(2) 4 | pp ary 5 | pp ary.delete(2) 6 | pp ary 7 | 8 | # => ary = [1, 2, 3, 4, 5] 9 | # => ary.delete(2) = true 10 | # => ary = [1, 3, 4, 5] 11 | # => ary.delete(2) = false 12 | # => ary = [1, 3, 4, 5] 13 | -------------------------------------------------------------------------------- /Array/delete_at.cr: -------------------------------------------------------------------------------- 1 | ary = [1,2,3,4,5] 2 | pp ary 3 | pp ary.delete_at(1) 4 | pp ary 5 | pp ary.delete_at(3) 6 | pp ary 7 | 8 | # => ary = [1, 2, 3, 4, 5] 9 | # => ary.delete_at(1) = 2 10 | # => ary = [1, 3, 4, 5] 11 | # => ary.delete_at(3) = 5 12 | # => ary = [1, 3, 4] -------------------------------------------------------------------------------- /Array/delete_if.cr: -------------------------------------------------------------------------------- 1 | ary = [1,2,3,4,5] 2 | pp ary 3 | pp ary.delete_if{ |e|e.odd? } 4 | pp ary 5 | ary = [1,2,3,4,5] 6 | pp ary.delete_if{ |e|e.even? } 7 | pp ary 8 | 9 | # => ary = [1, 2, 3, 4, 5] 10 | # => ary.delete_if(&.odd?) = true 11 | # => ary = [2, 4] 12 | # => ary.delete_if(&.even?) = true 13 | # => ary = [1, 3, 5] -------------------------------------------------------------------------------- /Array/dup.cr: -------------------------------------------------------------------------------- 1 | ary = [["a", "b"], ["c", "d", "e"]] 2 | ary2 = ary.dup 3 | ary[0][0] = "z" 4 | puts ary #=> [["z", "b"], ["c", "d", "e"]] 5 | puts ary2 #=> [["z", "b"], ["c", "d", "e"]] 6 | 7 | ary2 << ["f", "g"] 8 | puts ary #=> [["z", "b"], ["c", "d", "e"]] 9 | puts ary2 #=> [["z", "b"], ["c", "d", "e"], ["f", "g"]] 10 | -------------------------------------------------------------------------------- /Array/each.cr: -------------------------------------------------------------------------------- 1 | hoges = %w(hoge hige hage) 2 | pp hoges.each 3 | hoges.each { |e|pp e } 4 | 5 | # => hoges.each = # 6 | # => e = "hoge" 7 | # => e = "hige" 8 | # => e = "hage" -------------------------------------------------------------------------------- /Array/each_index.cr: -------------------------------------------------------------------------------- 1 | hoges = %w(hoge hige hage) 2 | hoges.each_index{ |e|pp e } 3 | pp hoges.each_index 4 | 5 | # => e = 0 6 | # => e = 1 7 | # => e = 2 8 | # => hoges.each_index = # -------------------------------------------------------------------------------- /Array/empty.cr: -------------------------------------------------------------------------------- 1 | pp Array(String).new.empty? 2 | pp [nil].empty? 3 | pp ['a'].empty? 4 | pp [1].empty? 5 | 6 | # => Array(String).new.empty? = true 7 | # => [nil].empty? = false 8 | # => ['a'].empty? = false 9 | # => [1].empty? = false 10 | -------------------------------------------------------------------------------- /Array/eq.cr: -------------------------------------------------------------------------------- 1 | hoges = %w(hoge hige hage) 2 | pp hoges == hoges 3 | pp hoges == %w(hoge hige hage) 4 | pp hoges == %w(hoge hige hege) 5 | 6 | # => hoges == hoges = true 7 | # => hoges == ["hoge", "hige", "hage"] = true 8 | # => hoges == ["hoge", "hige", "hege"] = false 9 | -------------------------------------------------------------------------------- /Array/equals.cr: -------------------------------------------------------------------------------- 1 | hoges = %w(hoge hige hage) 2 | puts hoges.equals?(hoges) {|a,b|a==b} 3 | puts hoges.equals?(%w(hoge hige hage)) {|a,b|a==b} 4 | puts hoges.equals?(%w(hoge hige hege)) {|a,b|a==b} 5 | 6 | # => true 7 | # => true 8 | # => false -------------------------------------------------------------------------------- /Array/first.cr: -------------------------------------------------------------------------------- 1 | list = (1..20).to_a 2 | pp list.first 3 | list = (1..20).to_a 4 | list.first {puts "not empty case, size == 0"} 5 | empty_list = Array(String).new 6 | empty_list.first {puts "empty case, size == 0"} 7 | -------------------------------------------------------------------------------- /Array/hash.cr: -------------------------------------------------------------------------------- 1 | hoges = ["hoge", "hige", "hage"] 2 | pp hoges.hash 3 | 4 | # => hoges.hash = -1106617536 5 | -------------------------------------------------------------------------------- /Array/insert.cr: -------------------------------------------------------------------------------- 1 | hoges = ["hoge", "hige", "hage"] 2 | pp hoges.insert(1, "insert1") 3 | pp hoges 4 | pp hoges.insert(3, "insert2") 5 | pp hoges 6 | 7 | # => hoges.insert(1, "insert1") = ["hoge", "insert1", "hige", "hage"] 8 | # => hoges = ["hoge", "insert1", "hige", "hage"] 9 | # => hoges.insert(3, "insert2") = ["hoge", "insert1", "hige", "insert2", "hage"] 10 | # => hoges = ["hoge", "insert1", "hige", "insert2", "hage"] 11 | -------------------------------------------------------------------------------- /Array/inspect.cr: -------------------------------------------------------------------------------- 1 | pp [1, 2, 3].inspect 2 | pp [1, 2, 3].to_s 3 | 4 | # => [1, 2, 3].inspect = "[1, 2, 3]" 5 | # => [1, 2, 3].to_s = "[1, 2, 3]" 6 | -------------------------------------------------------------------------------- /Array/last.cr: -------------------------------------------------------------------------------- 1 | list = (1..20).to_a 2 | pp list.last 3 | list = (1..20).to_a 4 | list.last {puts "not empty case, size == 0"} 5 | empty_list = Array(String).new 6 | empty_list.last {puts "empty case, size == 0"} 7 | 8 | # => list.last = 20 9 | # => empty case, size == 0 -------------------------------------------------------------------------------- /Array/last_q.cr: -------------------------------------------------------------------------------- 1 | list = (1..20).to_a 2 | pp list.first? 3 | pp list.last? 4 | list = Array(Int32).new 5 | pp list.first? 6 | pp list.last? 7 | begin 8 | list.first 9 | rescue e 10 | pp e.message 11 | end 12 | 13 | # => list.first? = 1 14 | # => list.last? = 20 15 | # => list.first? = nil 16 | # => list.last? = nil 17 | # => e.message = "Index out of bounds" -------------------------------------------------------------------------------- /Array/length.cr: -------------------------------------------------------------------------------- 1 | hoges = ["hoge", "hige", "hage"] 2 | pp hoges.length 3 | hoges << "hege" 4 | pp hoges.length 5 | 6 | # => hoges.length = 3 7 | # => hoges.length = 4 8 | -------------------------------------------------------------------------------- /Array/map.cr: -------------------------------------------------------------------------------- 1 | hoges = ["hoge", "hige", "hage"] 2 | pp hoges.map(&.upcase) 3 | pp hoges.map{|e|e.upcase} 4 | 5 | # => hoges.map(&.upcase) = ["HOGE", "HIGE", "HAGE"] 6 | # => hoges.map(&.upcase) = ["HOGE", "HIGE", "HAGE"] -------------------------------------------------------------------------------- /Array/map_with_index.cr: -------------------------------------------------------------------------------- 1 | hoges = ["hoge", "hige", "hage"] 2 | pp hoges.map_with_index{|e,i|e + i.to_s} 3 | 4 | # => hoges.map_with_index do |e, i| 5 | # => e + i.to_s 6 | # => end = ["hoge0", "hige1", "hage2"] -------------------------------------------------------------------------------- /Array/new1.cr: -------------------------------------------------------------------------------- 1 | defaults = ["Hoge", 1, true] 2 | defaults.each_with_index do |default, i| 3 | pp Array.new(i + 2, "Hoge") 4 | end 5 | 6 | # => Array.new(i + 2, "Hoge") = ["Hoge", "Hoge"] 7 | # => Array.new(i + 2, "Hoge") = ["Hoge", "Hoge", "Hoge"] 8 | # => Array.new(i + 2, "Hoge") = ["Hoge", "Hoge", "Hoge", "Hoge"] 9 | -------------------------------------------------------------------------------- /Array/pipe.cr: -------------------------------------------------------------------------------- 1 | hoges = ["hoge", "hige", "hage"] 2 | pp hoges | [ "c", "d", "a", "hage" ] 3 | 4 | # => hoges | ["c", "d", "a", "hage"] = ["hoge", "hige", "hage", "c", "d", "a"] 5 | -------------------------------------------------------------------------------- /Array/plus.cr: -------------------------------------------------------------------------------- 1 | hoges = ["hoge", "hige", "hage"] 2 | pp hoges + ["hoge", "hage", "hoo"] 3 | 4 | # => hoges + ["hoge", "hage", "hoo"] = ["hoge", "hige", "hage", "hoge", "hage", "hoo"] -------------------------------------------------------------------------------- /Array/pop.cr: -------------------------------------------------------------------------------- 1 | hoges = (1..10).to_a 2 | pp hoges.pop(3) 3 | pp hoges 4 | pp hoges.pop(3) 5 | pp hoges 6 | 7 | # => hoges.pop(3) = [8, 9, 10] 8 | # => hoges = [1, 2, 3, 4, 5, 6, 7] 9 | # => hoges.pop(3) = [5, 6, 7] 10 | # => hoges = [1, 2, 3, 4] 11 | -------------------------------------------------------------------------------- /Array/pop_q.cr: -------------------------------------------------------------------------------- 1 | hoges = (1..10).to_a 2 | hoges.pop(2) 3 | pp hoges.pop? 4 | hoges.pop(8) 5 | pp hoges.pop? 6 | 7 | # => hoges.pop? = 8 8 | # => hoges.pop? = nil 9 | -------------------------------------------------------------------------------- /Array/product.cr: -------------------------------------------------------------------------------- 1 | hoges = (1..3).to_a 2 | pp hoges.product((4..7).to_a) 3 | hoges.product((4..7).to_a) { |a,b|puts "#{a}:#{b}"} 4 | 5 | # => hoges.product((::Range.new(4, 7, false)).to_a) = [{1, 4}, {1, 5}, {1, 6}, {1, 7}, {2, 4}, {2, 5}, {2, 6}, {2, 7}, {3, 4}, {3, 5}, {3, 6}, {3, 7}] 6 | # => 1:4 7 | # => 1:5 8 | # => 1:6 9 | # => 1:7 10 | # => 2:4 11 | # => 2:5 12 | # => 2:6 13 | # => 2:7 14 | # => 3:4 15 | # => 3:5 16 | # => 3:6 17 | # => 3:7 18 | -------------------------------------------------------------------------------- /Array/push.cr: -------------------------------------------------------------------------------- 1 | hoges = ["hoge", "hige", "hage"] 2 | pp hoges << "hege" 3 | 4 | # => hoges << "hege" = ["hoge", "hige", "hage", "hege"] -------------------------------------------------------------------------------- /Array/push_.cr: -------------------------------------------------------------------------------- 1 | hoges = (1..10).to_a 2 | pp hoges.push(11) 3 | pp hoges 4 | pp hoges.push(12,13,14,15) 5 | pp hoges 6 | 7 | # => hoges.push(11) = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] 8 | # => hoges = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] 9 | # => hoges.push(12, 13, 14, 15) = {12, 13, 14, 15} 10 | # => hoges = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] 11 | -------------------------------------------------------------------------------- /Array/reject.cr: -------------------------------------------------------------------------------- 1 | hoges = ["hoge", "hige", "hage"] 2 | pp hoges.reject!("hige") 3 | pp hoges 4 | 5 | # => hoges = ["hoge", "hige", "hage"] 6 | # => hoges = ["hoge", "hage"] 7 | -------------------------------------------------------------------------------- /Array/replace.cr: -------------------------------------------------------------------------------- 1 | hoges = ["hoge", "hige", "hage"] 2 | pp hoges 3 | pp hoges.replace(["ほげ", "ひげ", "はげ"]) 4 | pp hoges 5 | 6 | # => hoges = ["hoge", "hige", "hage"] 7 | # => hoges.replace(["ほげ", "ひげ", "はげ"]) = ["ほげ", "ひげ", "はげ"] 8 | # => hoges = ["ほげ", "ひげ", "はげ"] 9 | -------------------------------------------------------------------------------- /Array/reverse.cr: -------------------------------------------------------------------------------- 1 | hoges = ["hoge", "hige", "hage"] 2 | pp hoges.reverse 3 | 4 | # => hoges.reverse = ["hage", "hige", "hoge"] 5 | -------------------------------------------------------------------------------- /Array/reverse_each.cr: -------------------------------------------------------------------------------- 1 | hoges = %w(hoge hige hage) 2 | pp hoges.reverse_each 3 | hoges.reverse_each { |e|pp e + "-plus" } 4 | 5 | # => hoges.reverse_each = # 6 | # => e + "-plus" = "hage-plus" 7 | # => e + "-plus" = "hige-plus" 8 | # => e + "-plus" = "hoge-plus" 9 | -------------------------------------------------------------------------------- /Array/rindex.cr: -------------------------------------------------------------------------------- 1 | hoges = %w(hoge hige hage) 2 | pp hoges.rindex("hoge") 3 | pp hoges.rindex {|e|e =~ /^h/} 4 | pp hoges.rindex {|e|e == "hoge"} 5 | 6 | # => hoges.rindex("hoge") = 0 7 | # => hoges.rindex(&.=~(/^h/)) = 2 8 | # => hoges.rindex(&.= = "hoge") = 0 9 | -------------------------------------------------------------------------------- /Array/sample.cr: -------------------------------------------------------------------------------- 1 | hoges = %w(hoge hige hage) 2 | pp hoges.sample(2) 3 | pp hoges.sample(2) 4 | pp hoges.sample 5 | pp hoges.sample 6 | 7 | # => hoges.sample(2) = ["hage", "hige"] 8 | # => hoges.sample(2) = ["hige", "hoge"] 9 | # => hoges.sample = "hage" 10 | # => hoges.sample = "hige" 11 | -------------------------------------------------------------------------------- /Array/select.cr: -------------------------------------------------------------------------------- 1 | hoges = ["hoge", "hige", "hage"] 2 | pp hoges.select!{|e|e=~/h[oi]ge/} 3 | pp hoges 4 | 5 | # => hoges.select!(&.=~(/h[oi]ge/)) = ["hoge", "hige"] 6 | # => hoges = ["hoge", "hige"] 7 | -------------------------------------------------------------------------------- /Array/shift.cr: -------------------------------------------------------------------------------- 1 | hoges = ["hoge", "hige", "hage"] 2 | pp hoges.shift 3 | pp hoges 4 | pp hoges.shift 5 | pp hoges 6 | 7 | # => hoges.shift = "hoge" 8 | # => hoges = ["hige", "hage"] 9 | # => hoges.shift = "hige" 10 | # => hoges = ["hage"] 11 | 12 | -------------------------------------------------------------------------------- /Array/shift_q.cr: -------------------------------------------------------------------------------- 1 | hoges = ["hoge", "hige", "hage"] 2 | pp hoges.shift 3 | pp hoges.shift 4 | pp hoges 5 | pp hoges.shift 6 | pp hoges 7 | begin 8 | hoges.shift 9 | rescue e 10 | pp e.message 11 | end 12 | pp hoges.shift? 13 | -------------------------------------------------------------------------------- /Array/shuffle.cr: -------------------------------------------------------------------------------- 1 | hoges = %w(hoge hige hage) 2 | 3.times { 3 | pp hoges.shuffle 4 | pp hoges 5 | } 6 | 7 | 3.times { 8 | pp hoges.shuffle! 9 | pp hoges 10 | } 11 | 12 | # => hoges.shuffle = ["hige", "hage", "hoge"] 13 | # => hoges = ["hoge", "hige", "hage"] 14 | # => hoges.shuffle = ["hige", "hoge", "hage"] 15 | # => hoges = ["hoge", "hige", "hage"] 16 | # => hoges.shuffle = ["hage", "hige", "hoge"] 17 | # => hoges = ["hoge", "hige", "hage"] 18 | # => hoges.shuffle! = ["hage", "hige", "hoge"] 19 | # => hoges = ["hage", "hige", "hoge"] 20 | # => hoges.shuffle! = ["hage", "hige", "hoge"] 21 | # => hoges = ["hage", "hige", "hoge"] 22 | # => hoges.shuffle! = ["hige", "hage", "hoge"] 23 | # => hoges = ["hige", "hage", "hoge"] 24 | -------------------------------------------------------------------------------- /Array/size.cr: -------------------------------------------------------------------------------- 1 | hoges = %w(hoge hige hage) 2 | pp hoges.size 3 | pp hoges.length 4 | hoges.push("hege") 5 | pp hoges.size 6 | pp hoges.length 7 | 8 | # => hoges.size = 3 9 | # => hoges.length = 3 10 | # => hoges.size = 4 11 | # => hoges.length = 4 12 | -------------------------------------------------------------------------------- /Array/sort.cr: -------------------------------------------------------------------------------- 1 | hoges = %w(ahoge bhige chage) 2 | pp hoges.sort 3 | pp hoges.sort{|x,y|x[2].ord <=> y[2].ord} 4 | pp hoges 5 | pp hoges.sort!{|x,y|x[2].ord <=> y[2].ord} 6 | pp hoges 7 | 8 | # => hoges.sort = ["ahoge", "bhige", "chage"] 9 | # => hoges.sort do |x, y| 10 | # => (x[2]).ord <=> (y[2]).ord 11 | # => end = ["chage", "bhige", "ahoge"] 12 | # => hoges = ["ahoge", "bhige", "chage"] 13 | # => hoges.sort! do |x, y| 14 | # => (x[2]).ord <=> (y[2]).ord 15 | # => end = ["chage", "bhige", "ahoge"] 16 | # => hoges = ["chage", "bhige", "ahoge"] 17 | -------------------------------------------------------------------------------- /Array/square_brackets.cr: -------------------------------------------------------------------------------- 1 | hoges = %w(hoge hige hage) 2 | pp hoges[0] 3 | pp hoges[0..1] 4 | pp hoges[1..2] 5 | pp hoges[-2..-1] 6 | 7 | # => hoges[0] = "hoge" 8 | # => hoges[::Range.new(0, 1, false)] = ["hoge", "hige"] 9 | # => hoges[::Range.new(1, 2, false)] = ["hige", "hage"] 10 | # => hoges[::Range.new(-2, -1, false)] = ["hige", "hage"] -------------------------------------------------------------------------------- /Array/square_brackets_q.cr: -------------------------------------------------------------------------------- 1 | hoges = %w(hoge hige hage) 2 | (0..3).map { |i|pp hoges[i]? } 3 | 4 | begin 5 | hoges[3] 6 | rescue e 7 | pp e.message 8 | end 9 | 10 | # hoges[i]? = "hoge" 11 | # hoges[i]? = "hige" 12 | # hoges[i]? = "hage" 13 | # hoges[i]? = nil 14 | # e.message = "Index out of bounds" 15 | -------------------------------------------------------------------------------- /Array/swap.cr: -------------------------------------------------------------------------------- 1 | hoges = ["hoge", "hige", "hage"] 2 | pp hoges.swap(0,1) 3 | pp hoges 4 | pp hoges.swap(0,-1) 5 | pp hoges 6 | 7 | # => hoges.swap(0, 1) = ["hige", "hoge", "hage"] 8 | # => hoges = ["hige", "hoge", "hage"] 9 | # => hoges.swap(0, -1) = ["hage", "hoge", "hige"] 10 | # => hoges = ["hage", "hoge", "hige"] 11 | -------------------------------------------------------------------------------- /Array/to_a.cr: -------------------------------------------------------------------------------- 1 | hoges = ["hoge", "hige", "hage", "hoge", "hige", "hage"] 2 | pp hoges 3 | pp hoges.to_set 4 | 5 | # => hoges = ["hoge", "hige", "hage", "hoge", "hige", "hage"] 6 | # => hoges.to_set = Set{"hoge", "hige", "hage"} 7 | -------------------------------------------------------------------------------- /Array/to_s.cr: -------------------------------------------------------------------------------- 1 | hoges = ["hoge", "hige", "hage"] 2 | pp hoges.to_s 3 | 4 | # => hoges.to_s = "[\"hoge\", \"hige\", \"hage\"]" 5 | -------------------------------------------------------------------------------- /Array/transpose.cr: -------------------------------------------------------------------------------- 1 | hoges = %w(hoge hige hage) 2 | hogehoges = [hoges, hoges] 3 | pp hogehoges.transpose 4 | pp hogehoges 5 | 6 | # => hogehoges.transpose = [["hoge", "hoge"], ["hige", "hige"], ["hage", "hage"]] 7 | # => hogehoges = [["hoge", "hige", "hage"], ["hoge", "hige", "hage"]] 8 | -------------------------------------------------------------------------------- /Array/uniq.cr: -------------------------------------------------------------------------------- 1 | hoges = %w(hoge hige hage bar) 2 | 3 | pp hoges.uniq 4 | pp hoges.uniq{ |e|e[0] } 5 | 6 | # => hoges.uniq = ["hoge", "hige", "hage", "bar"] 7 | # => hoges.uniq(&.[](0)) = ["hoge", "bar"] 8 | -------------------------------------------------------------------------------- /Array/unshift.cr: -------------------------------------------------------------------------------- 1 | hoges = %w(hoge hige hage) 2 | 3 | pp hoges 4 | pp hoges.unshift("bar1") 5 | pp hoges 6 | pp hoges.unshift("bar2") 7 | pp hoges 8 | pp hoges.shift(2) 9 | pp hoges 10 | 11 | # => hoges = ["hoge", "hige", "hage"] 12 | # => hoges.unshift("bar1") = ["bar1", "hoge", "hige", "hage"] 13 | # => hoges = ["bar1", "hoge", "hige", "hage"] 14 | # => hoges.unshift("bar2") = ["bar2", "bar1", "hoge", "hige", "hage"] 15 | # => hoges = ["bar2", "bar1", "hoge", "hige", "hage"] 16 | # => hoges.shift(2) = ["bar2", "bar1"] 17 | # => hoges = ["hoge", "hige", "hage"] 18 | -------------------------------------------------------------------------------- /Array/update.cr: -------------------------------------------------------------------------------- 1 | hoges = %w(hoge hige hage) 2 | 3 | pp hoges.update(1){ |e|e + "*" } 4 | pp hoges 5 | pp hoges.update(0){ |e|e + "+" } 6 | pp hoges 7 | 8 | # => hoges.update(1, &.+("*")) = "hige*" 9 | # => hoges = ["hoge", "hige*", "hage"] 10 | # => hoges.update(0, &.+("+")) = "hoge+" 11 | # => hoges = ["hoge+", "hige*", "hage"] 12 | -------------------------------------------------------------------------------- /Array/values_at.cr: -------------------------------------------------------------------------------- 1 | hoges = %w(hoge hige hage) 2 | 3 | pp hoges.values_at(1) 4 | pp hoges 5 | pp hoges.values_at(-1) 6 | pp hoges 7 | 8 | # => hoges.values_at(1) = {"hige"} 9 | # => hoges = ["hoge", "hige", "hage"] 10 | # => hoges.values_at(-1) = {"hage"} 11 | # => hoges = ["hoge", "hige", "hage"] 12 | -------------------------------------------------------------------------------- /Array/zip.cr: -------------------------------------------------------------------------------- 1 | hoges = ["hoge", "hige", "hage"] 2 | pp hoges.zip(["hoo", "bar", "baz"]) 3 | 4 | # => hoges.zip(["hoo", "bar", "baz"]) = [{"hoge", "hoo"}, {"hige", "bar"}, {"hage", "baz"}] 5 | -------------------------------------------------------------------------------- /Base64/decode.cr: -------------------------------------------------------------------------------- 1 | require "base64" 2 | base = "hoge hige hage" 3 | pp base 4 | encoded = Base64.encode(base) 5 | pp encoded 6 | decoded = Base64.decode(encoded) 7 | pp decoded 8 | 9 | # => base = "hoge hige hage" 10 | # => encoded = "aG9nZSBoaWdlIGhhZ2U=\n" 11 | # => decoded = "hoge hige hage" 12 | -------------------------------------------------------------------------------- /Base64/encode.cr: -------------------------------------------------------------------------------- 1 | require "base64" 2 | pp Base64.encode("hoge hige hage") 3 | 4 | # => Base64.encode("hoge hige hage") = "aG9nZSBoaWdlIGhhZ2U=\n" -------------------------------------------------------------------------------- /Base64/strict_encode.cr: -------------------------------------------------------------------------------- 1 | require "base64" 2 | pp Base64.strict_encode("hoge hige hage") 3 | 4 | # => Base64.strict_encode("hoge hige hage") = "aG9nZSBoaWdlIGhhZ2U=" 5 | -------------------------------------------------------------------------------- /Base64/urlsafe_encode.cr: -------------------------------------------------------------------------------- 1 | require "base64" 2 | pp Base64.urlsafe_encode("hoge hige hage") 3 | 4 | # => Base64.urlsafe_encode("hoge hige hage") = "aG9nZSBoaWdlIGhhZ2U" 5 | -------------------------------------------------------------------------------- /BitArray/bracket.cr: -------------------------------------------------------------------------------- 1 | require "bit_array" 2 | ba = BitArray.new(8) 3 | pp ba 4 | pp ba[0] 5 | pp ba[1] 6 | pp ba[-1] 7 | 0.upto(3) { |i| ba[i*2] = true } 8 | pp ba[0] 9 | pp ba[1] 10 | pp ba[-1] 11 | 12 | # => ba = # 13 | # => ba[0] = false 14 | # => ba[1] = false 15 | # => ba[-1] = false 16 | # => ba[0] = true 17 | # => ba[1] = false 18 | # => ba[-1] = false 19 | -------------------------------------------------------------------------------- /BitArray/bracket_eq.cr: -------------------------------------------------------------------------------- 1 | require "bit_array" 2 | ba = BitArray.new(8) 3 | pp ba 4 | pp ba[0] 5 | pp ba[1] 6 | pp ba[-1] 7 | 0.upto(3) { |i| ba[i*2] = true } 8 | pp ba[0] 9 | pp ba[1] 10 | pp ba[-1] 11 | ba[-1] = true 12 | pp ba[-1] 13 | 14 | # => ba = # 15 | # => ba[0] = false 16 | # => ba[1] = false 17 | # => ba[-1] = false 18 | # => ba[0] = true 19 | # => ba[1] = false 20 | # => ba[-1] = false 21 | # => ba[-1] = true 22 | -------------------------------------------------------------------------------- /BitArray/invert.cr: -------------------------------------------------------------------------------- 1 | require "bit_array" 2 | ba1 = BitArray.new(8) 3 | pp ba1.to_s 4 | ba1.invert 5 | pp ba1.to_s 6 | -------------------------------------------------------------------------------- /BitArray/new.cr: -------------------------------------------------------------------------------- 1 | require "bit_array" 2 | ba = BitArray.new(8) 3 | pp ba 4 | 5 | # => ba = # 6 | -------------------------------------------------------------------------------- /BitArray/toggle.cr: -------------------------------------------------------------------------------- 1 | require "bit_array" 2 | ba1 = BitArray.new(8) 3 | pp ba1.to_s 4 | pp ba1.toggle(2) 5 | pp ba1.to_s 6 | pp ba1.toggle(2) 7 | pp ba1.to_s 8 | 9 | # => ba1.to_s = "BitArray[00000000]" 10 | # => ba1.toggle(2) = 4 11 | # => ba1.to_s = "BitArray[00100000]" 12 | # => ba1.toggle(2) = 0 13 | # => ba1.to_s = "BitArray[00000000]" 14 | -------------------------------------------------------------------------------- /Bool/and.cr: -------------------------------------------------------------------------------- 1 | [[true, true], [true, false], [false, true], [false, false]].each do |e| 2 | a = e.first 3 | b = e.last 4 | puts "case a = #{a}, b = #{b}" 5 | pp a & b 6 | end 7 | -------------------------------------------------------------------------------- /Bool/eqeq.cr: -------------------------------------------------------------------------------- 1 | pp !true 2 | pp !false 3 | pp true.! 4 | pp false.! 5 | 6 | [[true, true], [true, false], [false, true], [false, false]].each do |e| 7 | a = e.first 8 | b = e.last 9 | puts "case a = #{a}, b = #{b}" 10 | pp a == b 11 | end 12 | -------------------------------------------------------------------------------- /Bool/exclamation.cr: -------------------------------------------------------------------------------- 1 | pp !true 2 | pp !false 3 | pp true.! 4 | pp false.! 5 | 6 | # => !true = false 7 | # => !false = true 8 | # => !true = false 9 | # => !false = true 10 | -------------------------------------------------------------------------------- /Bool/not_eq.cr: -------------------------------------------------------------------------------- 1 | pp !true 2 | pp !false 3 | pp true.! 4 | pp false.! 5 | 6 | [[true, true], [true, false], [false, true], [false, false]].each do |e| 7 | a = e.first 8 | b = e.last 9 | puts "case a = #{a}, b = #{b}" 10 | pp a != b 11 | end 12 | -------------------------------------------------------------------------------- /Bool/or.cr: -------------------------------------------------------------------------------- 1 | pp !true 2 | pp !false 3 | pp true.! 4 | pp false.! 5 | 6 | [[true, true], [true, false], [false, true], [false, false]].each do |e| 7 | a = e.first 8 | b = e.last 9 | puts "case a = #{a}, b = #{b}" 10 | pp a | b 11 | end 12 | -------------------------------------------------------------------------------- /CSV/build.cr: -------------------------------------------------------------------------------- 1 | require "csv" 2 | 3 | ret = CSV.build do |csv| 4 | csv.row "header1", "header2" 5 | csv.row "column1_1", "column1_2" 6 | csv.row "column2_1", "column2_2" 7 | end 8 | 9 | pp ret 10 | # => ret = "header1,header2\ncolumn1_1,column1_2\ncolumn2_1,column2_2\n" -------------------------------------------------------------------------------- /CSV/each_row.cr: -------------------------------------------------------------------------------- 1 | require "csv" 2 | 3 | csv =<<-EOS 4 | hoge,hige 5 | hage,hege 6 | EOS 7 | 8 | ret = CSV.each_row(csv) { |e|pp e } 9 | 10 | # => e = ["hoge", "hige"] 11 | # => e = ["hage", "hege"] 12 | -------------------------------------------------------------------------------- /CSV/parse.cr: -------------------------------------------------------------------------------- 1 | require "csv" 2 | 3 | csv =<<-EOS 4 | hoge,hige 5 | hage,hege 6 | EOS 7 | 8 | ret = CSV.parse(csv) 9 | pp ret 10 | 11 | # => ret = [["hoge", "hige"], ["hage", "hege"]] 12 | -------------------------------------------------------------------------------- /Char/alpha.cr: -------------------------------------------------------------------------------- 1 | ['a', 'z', 'A', 'Z', 'あ', '@', '{'].each do |e| 2 | pp e 3 | pp e.alpha? 4 | end 5 | 6 | # => e = 'a' 7 | # => e.alpha? = true 8 | # => e = 'z' 9 | # => e.alpha? = true 10 | # => e = 'A' 11 | # => e.alpha? = true 12 | # => e = 'Z' 13 | # => e.alpha? = true 14 | # => e = 'あ' 15 | # => e.alpha? = false 16 | # => e = '@' 17 | # => e.alpha? = false 18 | # => e = '{' 19 | # => e.alpha? = false 20 | -------------------------------------------------------------------------------- /Char/alphanumeric.cr: -------------------------------------------------------------------------------- 1 | ['a', 'z', 'A', 'Z', '0', '9','あ', '@', '{'].each do |e| 2 | pp e 3 | pp e.alphanumeric? 4 | end 5 | 6 | # => e = 'a' 7 | # => e.alphanumeric? = true 8 | # => e = 'z' 9 | # => e.alphanumeric? = true 10 | # => e = 'A' 11 | # => e.alphanumeric? = true 12 | # => e = 'Z' 13 | # => e.alphanumeric? = true 14 | # => e = '0' 15 | # => e.alphanumeric? = true 16 | # => e = '9' 17 | # => e.alphanumeric? = true 18 | # => e = 'あ' 19 | # => e.alphanumeric? = false 20 | # => e = '@' 21 | # => e.alphanumeric? = false 22 | # => e = '{' 23 | # => e.alphanumeric? = false 24 | -------------------------------------------------------------------------------- /Char/comparison.cr: -------------------------------------------------------------------------------- 1 | pp 'b' <=> 'a' 2 | pp 'b' <=> 'b' 3 | pp 'b' <=> 'c' 4 | 5 | # => 'b' <=> 'a' = 1 6 | # => 'b' <=> 'b' = 0 7 | # => 'b' <=> 'c' = -1 8 | -------------------------------------------------------------------------------- /Char/eq.cr: -------------------------------------------------------------------------------- 1 | pp 'b' == 'a' 2 | pp 'b' == 'b' 3 | pp 'b' == 'c' 4 | 5 | # => 'b' == 'a' = false 6 | # => 'b' == 'b' = true 7 | # => 'b' == 'c' = false 8 | -------------------------------------------------------------------------------- /Char/greater.cr: -------------------------------------------------------------------------------- 1 | pp 'b' > 'a' 2 | pp 'b' > 'b' 3 | pp 'b' > 'c' 4 | 5 | # => 'b' > 'a' = true 6 | # => 'b' > 'b' = false 7 | # => 'b' > 'c' = false 8 | -------------------------------------------------------------------------------- /Char/less.cr: -------------------------------------------------------------------------------- 1 | pp 'b' < 'a' 2 | pp 'b' < 'b' 3 | pp 'b' < 'c' 4 | 5 | # => 'b' < 'a' = false 6 | # => 'b' < 'b' = false 7 | # => 'b' < 'c' = true 8 | -------------------------------------------------------------------------------- /Char/less_eq.cr: -------------------------------------------------------------------------------- 1 | pp 'b' <= 'a' 2 | pp 'b' <= 'b' 3 | pp 'b' <= 'c' 4 | 5 | # => 'b' <= 'a' = false 6 | # => 'b' <= 'b' = true 7 | # => 'b' <= 'c' = true 8 | -------------------------------------------------------------------------------- /Char/minus.cr: -------------------------------------------------------------------------------- 1 | pp 'a' - 'a' 2 | pp 'a' - 'b' 3 | pp 'b' - 'a' 4 | 5 | # => 'a' - 'a' = 0 6 | # => 'a' - 'b' = -1 7 | # => 'b' - 'a' = 1 8 | -------------------------------------------------------------------------------- /Char/not_eq.cr: -------------------------------------------------------------------------------- 1 | pp 'a' != 'a' 2 | pp 'a' != 'b' 3 | 4 | # => 'a' != 'a' = false 5 | # => 'a' != 'b' = true 6 | -------------------------------------------------------------------------------- /Char/pred.cr: -------------------------------------------------------------------------------- 1 | ['a', 'z', 'A', 'Z', '0', '9','あ', '@', '{', '💩', '\f', ' ', '\n'].each do |e| 2 | puts "=== #{e} ===" 3 | pp e.pred 4 | end 5 | 6 | # => === a === 7 | # => e.pred = '`' 8 | # => === z === 9 | # => e.pred = 'y' 10 | # => === A === 11 | # => e.pred = '@' 12 | # => === Z === 13 | # => e.pred = 'Y' 14 | # => === 0 === 15 | # => e.pred = '/' 16 | # => === 9 === 17 | # => e.pred = '8' 18 | # => === あ === 19 | # => e.pred = 'ぁ' 20 | # => === @ === 21 | # => e.pred = '?' 22 | # => === { === 23 | # => e.pred = 'z' 24 | # => === 💩 === 25 | # => e.pred = '💨' 26 | # => === === 27 | # => e.pred = '\v' 28 | # => === === 29 | # => e.pred = '\u{1f}' 30 | # => === 31 | # => === 32 | # => e.pred = '\t' 33 | -------------------------------------------------------------------------------- /Char/succ.cr: -------------------------------------------------------------------------------- 1 | ['a', 'z', 'A', 'Z', '0', '9','あ', '@', '{', '💩', '\f', ' ', '\n'].each do |e| 2 | puts "=== #{e} ===" 3 | pp e.succ 4 | end 5 | 6 | # => === a === 7 | # => e.succ = 'b' 8 | # => === z === 9 | # => e.succ = '{' 10 | # => === A === 11 | # => e.succ = 'B' 12 | # => === Z === 13 | # => e.succ = '[' 14 | # => === 0 === 15 | # => e.succ = '1' 16 | # => === 9 === 17 | # => e.succ = ':' 18 | # => === あ === 19 | # => e.succ = 'ぃ' 20 | # => === @ === 21 | # => e.succ = 'A' 22 | # => === { === 23 | # => e.succ = '|' 24 | # => === 💩 === 25 | # => e.succ = '💪' 26 | # => === === 27 | # => e.succ = '\r' 28 | # => === === 29 | # => e.succ = '!' 30 | # => === 31 | # => === 32 | # => e.succ = '\v' 33 | -------------------------------------------------------------------------------- /Char/upcase.cr: -------------------------------------------------------------------------------- 1 | ['a', 'z', 'A', 'Z', '0', '9','あ', '@', '{', '💩', '\f', ' ', '\n'].each do |e| 2 | puts "=== #{e} ===" 3 | pp e.upcase 4 | end 5 | 6 | # => === a === 7 | # => e.upcase = 'A' 8 | # => === z === 9 | # => e.upcase = 'Z' 10 | # => === A === 11 | # => e.upcase = 'A' 12 | # => === Z === 13 | # => e.upcase = 'Z' 14 | # => === 0 === 15 | # => e.upcase = '0' 16 | # => === 9 === 17 | # => e.upcase = '9' 18 | # => === あ === 19 | # => e.upcase = 'あ' 20 | # => === @ === 21 | # => e.upcase = '@' 22 | # => === { === 23 | # => e.upcase = '{' 24 | # => === 💩 === 25 | # => e.upcase = '💩' 26 | # => === === 27 | # => e.upcase = '\f' 28 | # => === === 29 | # => e.upcase = ' ' 30 | # => === 31 | # => === 32 | # => e.upcase = '\n' 33 | -------------------------------------------------------------------------------- /Char/whitespace.cr: -------------------------------------------------------------------------------- 1 | ['a', 'z', 'A', 'Z', '0', '9','あ', '@', '{', '💩', '\f', ' ', '\n'].each do |e| 2 | puts "=== #{e} ===" 3 | pp e.whitespace? 4 | end -------------------------------------------------------------------------------- /Deque/at.cr: -------------------------------------------------------------------------------- 1 | require "deque" 2 | 3 | ary = (1..5).to_a 4 | deque = Deque.new(ary) 5 | pp deque 6 | 7 | 5.times { |i|pp deque.at(i) } 8 | 9 | # => deque = Deque{1, 2, 3, 4, 5} 10 | # => deque.at(i) = 1 11 | # => deque.at(i) = 2 12 | # => deque.at(i) = 3 13 | # => deque.at(i) = 4 14 | # => deque.at(i) = 5 15 | -------------------------------------------------------------------------------- /Deque/bracket.cr: -------------------------------------------------------------------------------- 1 | require "deque" 2 | 3 | deque = Deque.new(5, 0) 4 | pp deque 5 | deque[0] = 1 6 | pp deque 7 | deque[-1] = 4 8 | pp deque 9 | 10 | # => deque = Deque{0, 0, 0, 0, 0} 11 | # => deque = Deque{1, 0, 0, 0, 0} 12 | # => deque = Deque{1, 0, 0, 0, 4} 13 | -------------------------------------------------------------------------------- /Deque/bracket_q.cr: -------------------------------------------------------------------------------- 1 | require "deque" 2 | 3 | deque = Deque.new(5, 0) 4 | pp deque[4] 5 | begin 6 | deque[5] 7 | rescue e 8 | pp e.message 9 | end 10 | pp deque[5]? 11 | 12 | # => deque[4] = 0 13 | # => e.message = "Index out of bounds" 14 | # => deque[5]? = nil 15 | -------------------------------------------------------------------------------- /Deque/clear.cr: -------------------------------------------------------------------------------- 1 | require "deque" 2 | 3 | ary = (1..5).to_a 4 | deque = Deque.new(ary) 5 | pp deque 6 | deque.clear 7 | pp deque 8 | 9 | # => deque = Deque{1, 2, 3, 4, 5} 10 | # => deque = Deque{} 11 | -------------------------------------------------------------------------------- /Deque/clone.cr: -------------------------------------------------------------------------------- 1 | require "deque" 2 | 3 | ary = (1..5).to_a 4 | deque = Deque.new(ary) 5 | pp deque 6 | clone_deque = deque.clone 7 | pp clone_deque 8 | 9 | 5.times { |i|pp deque.at(i) } 10 | 11 | # => deque = Deque{1, 2, 3, 4, 5} 12 | # => clone_deque = Deque{1, 2, 3, 4, 5} 13 | -------------------------------------------------------------------------------- /Deque/concat.cr: -------------------------------------------------------------------------------- 1 | require "deque" 2 | 3 | ary = (1..5).to_a 4 | deque = Deque.new(ary) 5 | pp deque 6 | pp deque.concat([9, 8, 7, 6]) 7 | pp deque 8 | 9 | # => deque = Deque{1, 2, 3, 4, 5} 10 | # => deque.concat([9, 8, 7, 6]) = Deque{1, 2, 3, 4, 5, 9, 8, 7, 6} 11 | # => deque = Deque{1, 2, 3, 4, 5, 9, 8, 7, 6} 12 | -------------------------------------------------------------------------------- /Deque/delete_at.cr: -------------------------------------------------------------------------------- 1 | require "deque" 2 | 3 | ary = (1..5).to_a 4 | deque = Deque.new(ary) 5 | pp deque.delete_at(0) 6 | pp deque 7 | pp deque.delete_at(-1) 8 | pp deque 9 | 10 | # => deque.delete_at(0) = 1 11 | # => deque = Deque{2, 3, 4, 5} 12 | # => deque.delete_at(-1) = 5 13 | # => deque = Deque{2, 3, 4} 14 | -------------------------------------------------------------------------------- /Deque/dup.cr: -------------------------------------------------------------------------------- 1 | require "deque" 2 | 3 | ary = (1..5).to_a 4 | deque = Deque.new(ary) 5 | pp deque 6 | dupped_deque = deque.dup 7 | pp dupped_deque 8 | pp deque == dupped_deque 9 | pp deque.equals?(dupped_deque) {|x, y|x == y} 10 | 11 | # => deque = Deque{1, 2, 3, 4, 5} 12 | # => dupped_deque = Deque{1, 2, 3, 4, 5} 13 | # => deque == dupped_deque = true 14 | # => deque.equals?(dupped_deque) do |x, y| 15 | # => x == y 16 | # => end = true 17 | -------------------------------------------------------------------------------- /Deque/each.cr: -------------------------------------------------------------------------------- 1 | require "deque" 2 | 3 | ary = (1..5).to_a 4 | deque = Deque.new(ary) 5 | deque.each {|e|pp e} 6 | 7 | # => e = 1 8 | # => e = 2 9 | # => e = 3 10 | # => e = 4 11 | # => e = 5 12 | -------------------------------------------------------------------------------- /Deque/each_index.cr: -------------------------------------------------------------------------------- 1 | require "deque" 2 | 3 | ary = (1..5).to_a 4 | deque = Deque.new(ary) 5 | deque.each_index {|e|pp e} 6 | 7 | # => e = 0 8 | # => e = 1 9 | # => e = 2 10 | # => e = 3 11 | # => e = 4 12 | -------------------------------------------------------------------------------- /Deque/empty.cr: -------------------------------------------------------------------------------- 1 | require "deque" 2 | 3 | ary = (1..5).to_a 4 | deque1 = Deque.new(ary) 5 | pp deque1.empty? 6 | deque2 = Deque.new([1]) 7 | deque2.delete_at(0) 8 | pp deque2.empty? 9 | 10 | # => deque1.empty? = false 11 | # => deque2.empty? = true 12 | -------------------------------------------------------------------------------- /Deque/eqeq.cr: -------------------------------------------------------------------------------- 1 | require "deque" 2 | 3 | deque1 = Deque.new(5, 0) 4 | deque2 = Deque.new(5, 0) 5 | deque3 = Deque.new(5, 1) 6 | deque4 = Deque.new(4, 0) 7 | pp deque1 == deque2 8 | pp deque1 == deque3 9 | pp deque1 == deque4 10 | 11 | # => deque1 == deque2 = true 12 | # => deque1 == deque3 = false 13 | # => deque1 == deque4 = false 14 | -------------------------------------------------------------------------------- /Deque/equals.cr: -------------------------------------------------------------------------------- 1 | require "deque" 2 | 3 | deque1 = Deque.new(5, 0) 4 | deque2 = Deque.new(5, 0) 5 | deque3 = Deque.new(5, 1) 6 | deque4 = Deque.new(4, 0) 7 | deque1.equals?(deque2) { |a, b|pp a == b } 8 | deque1.equals?(deque3) { |a, b|pp a == b } 9 | deque1.equals?(deque4) { |a, b|pp a == b } 10 | 11 | # => a == b = true 12 | # => a == b = false -------------------------------------------------------------------------------- /Deque/first.cr: -------------------------------------------------------------------------------- 1 | require "deque" 2 | 3 | ary = (1..5).to_a 4 | deque = Deque.new(ary) 5 | pp deque.first 6 | 7 | # => deque.first = 1 8 | -------------------------------------------------------------------------------- /Deque/first_q.cr: -------------------------------------------------------------------------------- 1 | require "deque" 2 | 3 | ary = (1..5).to_a 4 | deque = Deque.new(ary) 5 | pp deque.first 6 | pp Deque.new(Array(Int32).new).first? 7 | 8 | # => (Deque.new(Array(Int32).new)).first? = nil 9 | -------------------------------------------------------------------------------- /Deque/insert.cr: -------------------------------------------------------------------------------- 1 | require "deque" 2 | 3 | deque = Deque.new(5, 0) 4 | pp deque 5 | deque.insert(0, 99) 6 | pp deque 7 | deque.insert(-1, 99) 8 | pp deque 9 | 10 | # => deque = Deque{0, 0, 0, 0, 0} 11 | # => deque = Deque{99, 0, 0, 0, 0, 0} 12 | # => deque = Deque{99, 0, 0, 0, 0, 0, 99} 13 | -------------------------------------------------------------------------------- /Deque/last.cr: -------------------------------------------------------------------------------- 1 | require "deque" 2 | 3 | ary = (1..5).to_a 4 | deque = Deque.new(ary) 5 | pp deque.last 6 | 7 | # => deque.last = 5 8 | -------------------------------------------------------------------------------- /Deque/last_q.cr: -------------------------------------------------------------------------------- 1 | require "deque" 2 | 3 | ary = (1..5).to_a 4 | deque = Deque.new(ary) 5 | pp deque.last 6 | pp Deque.new(Array(Int32).new).last? 7 | 8 | # => deque.last = 5 9 | # => (Deque.new(Array(Int32).new)).last? = nil 10 | -------------------------------------------------------------------------------- /Deque/ltlt.cr: -------------------------------------------------------------------------------- 1 | require "deque" 2 | 3 | deque = Deque.new(5, 0) 4 | (1..5).each do |i| 5 | deque << i 6 | pp deque 7 | end 8 | 9 | # => deque = Deque{0, 0, 0, 0, 0, 1} 10 | # => deque = Deque{0, 0, 0, 0, 0, 1, 2} 11 | # => deque = Deque{0, 0, 0, 0, 0, 1, 2, 3} 12 | # => deque = Deque{0, 0, 0, 0, 0, 1, 2, 3, 4} 13 | # => deque = Deque{0, 0, 0, 0, 0, 1, 2, 3, 4, 5} 14 | -------------------------------------------------------------------------------- /Deque/new.cr: -------------------------------------------------------------------------------- 1 | require "deque" 2 | 3 | deque = Deque.new(5, 0) 4 | pp deque 5 | deque.push(1) 6 | pp deque 7 | deque.push(2) 8 | pp deque 9 | deque.push(3) 10 | pp deque 11 | -------------------------------------------------------------------------------- /Deque/plus.cr: -------------------------------------------------------------------------------- 1 | require "deque" 2 | 3 | deque1 = Deque.new(5, 0) 4 | deque2 = Deque.new(5, 1) 5 | pp deque1 6 | pp deque2 7 | pp deque1 + deque2 8 | 9 | # => deque1 = Deque{0, 0, 0, 0, 0} 10 | # => deque2 = Deque{1, 1, 1, 1, 1} 11 | # => deque1 + deque2 = Deque{0, 0, 0, 0, 0, 1, 1, 1, 1, 1} 12 | -------------------------------------------------------------------------------- /Deque/pop.cr: -------------------------------------------------------------------------------- 1 | require "deque" 2 | 3 | ary = (1..5).to_a 4 | deque = Deque.new(ary) 5 | pp deque.pop 6 | pp deque 7 | pp deque.pop 8 | pp deque 9 | 10 | # => deque.pop = 5 11 | # => deque = Deque{1, 2, 3, 4} 12 | # => deque.pop = 4 13 | # => deque = Deque{1, 2, 3} 14 | -------------------------------------------------------------------------------- /Deque/pop_q.cr: -------------------------------------------------------------------------------- 1 | require "deque" 2 | 3 | ary = (1..5).to_a 4 | deque = Deque.new(ary) 5 | 6.times do 6 | pp deque.pop? 7 | pp deque 8 | end 9 | 10 | # => deque.pop? = 5 11 | # => deque = Deque{1, 2, 3, 4} 12 | # => deque.pop? = 4 13 | # => deque = Deque{1, 2, 3} 14 | # => deque.pop? = 3 15 | # => deque = Deque{1, 2} 16 | # => deque.pop? = 2 17 | # => deque = Deque{1} 18 | # => deque.pop? = 1 19 | # => deque = Deque{} 20 | # => deque.pop? = nil 21 | # => deque = Deque{} 22 | -------------------------------------------------------------------------------- /Deque/push.cr: -------------------------------------------------------------------------------- 1 | require "deque" 2 | 3 | ary = (1..5).to_a 4 | deque = Deque.new(ary) 5 | pp deque 6 | pp deque.push(6) 7 | pp deque 8 | 9 | # => deque = Deque{1, 2, 3, 4, 5} 10 | # => deque.push(6) = Deque{1, 2, 3, 4, 5, 6} 11 | # => deque = Deque{1, 2, 3, 4, 5, 6} 12 | -------------------------------------------------------------------------------- /Deque/reverse_each.cr: -------------------------------------------------------------------------------- 1 | require "deque" 2 | 3 | ary = (1..5).to_a 4 | deque = Deque.new(ary) 5 | deque.reverse_each { |e|pp e } 6 | 7 | # => e = 5 8 | # => e = 4 9 | # => e = 3 10 | # => e = 2 11 | # => e = 1 12 | -------------------------------------------------------------------------------- /Deque/rotate.cr: -------------------------------------------------------------------------------- 1 | require "deque" 2 | 3 | ary = (1..5).to_a 4 | deque = Deque.new(ary) 5 | deque.rotate! 6 | pp deque 7 | deque.rotate!(2) 8 | pp deque 9 | 10 | # => deque = Deque{2, 3, 4, 5, 1} 11 | # => deque = Deque{4, 5, 1, 2, 3} 12 | -------------------------------------------------------------------------------- /Deque/shift.cr: -------------------------------------------------------------------------------- 1 | require "deque" 2 | 3 | ary = (1..5).to_a 4 | deque = Deque.new(ary) 5 | pp deque.shift 6 | pp deque 7 | pp deque.shift 8 | pp deque 9 | 10 | # => deque.shift = 1 11 | # => deque = Deque{2, 3, 4, 5} 12 | # => deque.shift = 2 13 | # => deque = Deque{3, 4, 5} 14 | -------------------------------------------------------------------------------- /Deque/shift_q.cr: -------------------------------------------------------------------------------- 1 | require "deque" 2 | 3 | ary = (1..5).to_a 4 | deque = Deque.new(ary) 5 | 6.times { |e| pp deque.shift? } 6 | 7 | # => deque.shift? = 1 8 | # => deque.shift? = 2 9 | # => deque.shift? = 3 10 | # => deque.shift? = 4 11 | # => deque.shift? = 5 12 | # => deque.shift? = nil 13 | -------------------------------------------------------------------------------- /Deque/size.cr: -------------------------------------------------------------------------------- 1 | require "deque" 2 | 3 | ary = (1..5).to_a 4 | deque = Deque.new(ary) 5 | pp deque.size 6 | 7 | # => deque.size = 5 -------------------------------------------------------------------------------- /Deque/swap.cr: -------------------------------------------------------------------------------- 1 | require "deque" 2 | 3 | ary = (1..5).to_a 4 | deque = Deque.new(ary) 5 | pp deque 6 | deque.swap(0, 1) 7 | pp deque 8 | 9 | # => deque = Deque{1, 2, 3, 4, 5} 10 | # => deque = Deque{2, 1, 3, 4, 5} 11 | -------------------------------------------------------------------------------- /Deque/to_a.cr: -------------------------------------------------------------------------------- 1 | require "deque" 2 | 3 | ary = (1..5).to_a 4 | deque = Deque.new(ary) 5 | pp deque 6 | pp deque.class 7 | array = deque.to_a 8 | pp array 9 | pp array.class 10 | 11 | # => deque = Deque{1, 2, 3, 4, 5} 12 | # => deque.class = Deque(Int32) 13 | # => array = [1, 2, 3, 4, 5] 14 | # => array.class = Array(Int32) 15 | -------------------------------------------------------------------------------- /Deque/to_s.cr: -------------------------------------------------------------------------------- 1 | require "deque" 2 | 3 | ary = (1..5).to_a 4 | deque = Deque.new(ary) 5 | pp deque 6 | pp deque.to_s 7 | 8 | # => deque = Deque{1, 2, 3, 4, 5} 9 | # => deque.to_s = "Deque{1, 2, 3, 4, 5}" 10 | 11 | -------------------------------------------------------------------------------- /Deque/unshift.cr: -------------------------------------------------------------------------------- 1 | require "deque" 2 | 3 | ary = (1..5).to_a 4 | deque = Deque.new(ary) 5 | pp deque 6 | deque.unshift(6) 7 | pp deque 8 | 9 | # => deque = Deque{1, 2, 3, 4, 5} 10 | # => deque = Deque{6, 1, 2, 3, 4, 5} 11 | -------------------------------------------------------------------------------- /ENV/at.cr: -------------------------------------------------------------------------------- 1 | ENV["test"] = "test value" 2 | pp ENV["test"] 3 | 4 | # => ENV["test"] = "test value" -------------------------------------------------------------------------------- /ENV/at_eq.cr: -------------------------------------------------------------------------------- 1 | pp ENV["test"] = "test value" 2 | pp ENV["test"] 3 | 4 | # => ENV["test"] = "test value" = "test value" 5 | # => ENV["test"] = "test value" 6 | -------------------------------------------------------------------------------- /ENV/at_q.cr: -------------------------------------------------------------------------------- 1 | pp ENV["test"]? 2 | ENV["test"] = "test value" 3 | pp ENV["test"]? 4 | 5 | # => ENV["test"]? = nil 6 | # => ENV["test"]? = "test value" 7 | -------------------------------------------------------------------------------- /ENV/clear.cr: -------------------------------------------------------------------------------- 1 | ENV["test"] = "test value" 2 | pp ENV["test"] 3 | ENV.clear 4 | pp ENV["test"] 5 | 6 | # STDOUT 7 | # => ENV["test"] = "test value" 8 | 9 | # ERROUT 10 | # => Missing ENV key: "test" (KeyError) 11 | # => [134609833] *CallStack::unwind:Array(Pointer(Void)) +121 12 | # => [134609695] *CallStack#initialize:Array(Pointer(Void)) +31 13 | # => [134609637] *CallStack::new:CallStack +69 14 | # => [134710088] *KeyError +56 15 | # => [134709995] *KeyError::new:KeyError +139 16 | # => [134722756] *ENV::fetch:String +196 17 | # => [134722542] *ENV::[]:String +30 18 | # => [134590995] ??? 19 | # => [134599021] main +77 20 | # => [3074430103] __libc_start_main +247 21 | # => [134587617] ??? 22 | -------------------------------------------------------------------------------- /ENV/delete.cr: -------------------------------------------------------------------------------- 1 | ENV["test1"] = "test1 value" 2 | ENV["test2"] = "test2 value" 3 | pp ENV 4 | ENV.delete("test1") 5 | pp ENV 6 | 7 | # => ENV = {"PATH" => "/usr/local/bin:/usr/bin:/bin", "HOME" => "/home/crystal", "USER" => "crystal", "LOGNAME" => "crystal", "test1" => "test1 value", "test2" => "test2 value"} 8 | # => ENV = {"PATH" => "/usr/local/bin:/usr/bin:/bin", "HOME" => "/home/crystal", "USER" => "crystal", "LOGNAME" => "crystal", "test2" => "test2 value"} 9 | -------------------------------------------------------------------------------- /ENV/each.cr: -------------------------------------------------------------------------------- 1 | ENV["test1"] = "test1 value" 2 | ENV["test2"] = "test2 value" 3 | ENV.each {|e|pp e} 4 | 5 | # => e = "PATH" 6 | # => e = "HOME" 7 | # => e = "USER" 8 | # => e = "LOGNAME" 9 | # => e = "test1" 10 | # => e = "test2" 11 | -------------------------------------------------------------------------------- /ENV/fetch.cr: -------------------------------------------------------------------------------- 1 | ENV["test1"] = "test1 value" 2 | ENV["test2"] = "test2 value" 3 | ENV["test3"] = "test3 value" 4 | pp ENV.fetch("test1") {|e|e + "-hoge"} 5 | pp ENV.fetch("test4") {|e|e + "-hoge"} 6 | pp ENV.fetch("test1", "default") 7 | pp ENV.fetch("test4", "default") 8 | 9 | # => ENV.fetch("test1", &.+("-hoge")) = "test1 value" 10 | # => ENV.fetch("test4", &.+("-hoge")) = "test4-hoge" 11 | # => ENV.fetch("test1", "default") = "test1 value" 12 | # => ENV.fetch("test4", "default") = "default" 13 | -------------------------------------------------------------------------------- /ENV/has_key.cr: -------------------------------------------------------------------------------- 1 | pp ENV.has_key?("test") 2 | ENV["test"] = "test value" 3 | pp ENV.has_key?("test") 4 | 5 | # => ENV.has_key?("test") = false 6 | # => ENV.has_key?("test") = true 7 | -------------------------------------------------------------------------------- /ENV/keys.cr: -------------------------------------------------------------------------------- 1 | pp ENV.keys 2 | ENV["test1"] = "test1 value" 3 | ENV["test2"] = "test2 value" 4 | pp ENV.keys 5 | 6 | # => ENV.keys = ["PATH", "HOME", "USER", "LOGNAME"] 7 | # => ENV.keys = ["PATH", "HOME", "USER", "LOGNAME", "test1", "test2"] 8 | -------------------------------------------------------------------------------- /ENV/values.cr: -------------------------------------------------------------------------------- 1 | pp ENV.values 2 | ENV["test1"] = "test1 value" 3 | ENV["test2"] = "test2 value" 4 | pp ENV.values 5 | 6 | # => ENV.values = ["/usr/local/bin:/usr/bin:/bin", "/home/crystal", "crystal", "crystal"] 7 | # => ENV.values = ["/usr/local/bin:/usr/bin:/bin", "/home/crystal", "crystal", "crystal", "test1 value", "test2 value"] 8 | -------------------------------------------------------------------------------- /Enum/and.cr: -------------------------------------------------------------------------------- 1 | enum TF 2 | True 3 | False 4 | end 5 | 6 | pp TF.new(0) & TF.new(1) 7 | pp TF.new(1) & TF.new(0) 8 | pp TF.new(0) & TF.new(0) 9 | pp TF.new(1) & TF.new(1) 10 | 11 | # => (TF.new(0)) & TF.new(1) = True 12 | # => (TF.new(1)) & TF.new(0) = True 13 | # => (TF.new(0)) & TF.new(0) = True 14 | # => (TF.new(1)) & TF.new(1) = False 15 | -------------------------------------------------------------------------------- /Enum/comp.cr: -------------------------------------------------------------------------------- 1 | enum Hoges 2 | Hoge 3 | Hige 4 | Hage 5 | end 6 | 7 | pp Hoges::Hoge <=> Hoges::Hoge 8 | pp Hoges::Hoge <=> Hoges::Hige 9 | pp Hoges::Hage <=> Hoges::Hige 10 | 11 | # => Hoges::Hoge <=> Hoges::Hoge = 0 12 | # => Hoges::Hoge <=> Hoges::Hige = -1 13 | # => Hoges::Hage <=> Hoges::Hige = 1 14 | -------------------------------------------------------------------------------- /Enum/enum1.cr: -------------------------------------------------------------------------------- 1 | enum Hoges 2 | Hoge 3 | Hige 4 | Hage 5 | end 6 | 7 | ho = Hoges::Hoge 8 | pp ho.hoge? 9 | pp ho.hige? 10 | 11 | # => ho.hoge? = true 12 | # => ho.hige? = false 13 | -------------------------------------------------------------------------------- /Enum/enum2.cr: -------------------------------------------------------------------------------- 1 | enum Hoges 2 | Hoge 3 | Hige 4 | Hage 5 | end 6 | 7 | ho = Hoges::Hoge 8 | pp ho.hoge? 9 | pp ho.hige? 10 | 11 | hoge = Hoges.new(0) 12 | hige = Hoges.new(1) 13 | hage = Hoges.new(2) 14 | 15 | def print_hoges(e) 16 | case e 17 | when .hoge? 18 | puts e 19 | when .hige? 20 | puts e 21 | when .hage? 22 | puts e 23 | end 24 | end 25 | 26 | print_hoges(hoge) 27 | print_hoges(hige) 28 | print_hoges(hage) 29 | 30 | # => ho.hoge? = true 31 | # => ho.hige? = false 32 | # => Hoge 33 | # => Hige 34 | # => Hage 35 | -------------------------------------------------------------------------------- /Enum/eq.cr: -------------------------------------------------------------------------------- 1 | enum Hoges 2 | Hoge 3 | Hige 4 | Hage 5 | end 6 | 7 | pp Hoges::Hoge == Hoges::Hoge 8 | pp Hoges::Hoge == Hoges::Hage 9 | 10 | # => Hoges::Hoge == Hoges::Hoge = true 11 | # => Hoges::Hoge == Hoges::Hage = false 12 | -------------------------------------------------------------------------------- /Enum/from_value.cr: -------------------------------------------------------------------------------- 1 | enum Hoges 2 | Hoge 3 | Hige 4 | Hage 5 | end 6 | 7 | ho = Hoges.from_value(0) 8 | pp ho 9 | 10 | # => ho = Hoge 11 | -------------------------------------------------------------------------------- /Enum/from_value_q.cr: -------------------------------------------------------------------------------- 1 | enum Hoges 2 | Hoge 3 | Hige 4 | Hage 5 | end 6 | 7 | (0..(Hoges.names.size - 1)).each { |e|pp Hoges.from_value?(e) } 8 | 9 | # => Hoges.from_value?(e) = Hoge 10 | # => Hoges.from_value?(e) = Hige 11 | # => Hoges.from_value?(e) = Hage 12 | -------------------------------------------------------------------------------- /Enum/hash.cr: -------------------------------------------------------------------------------- 1 | enum Hoges 2 | Hoge 3 | Hige 4 | Hage 5 | end 6 | 7 | pp Hoges::Hoge.hash 8 | pp Hoges::Hage.hash 9 | 10 | # => Hoges::Hoge.hash = 0 11 | # => Hoges::Hage.hash = 2 12 | -------------------------------------------------------------------------------- /Enum/includes.cr: -------------------------------------------------------------------------------- 1 | enum Hoges 2 | Hoge 3 | Hige 4 | Hage 5 | end 6 | 7 | pp Hoges::Hoge.includes?(Hoges::Hoge) 8 | pp Hoges::Hoge.includes?(Hoges::Hage) 9 | pp Hoges::Hage.includes?(Hoges::Hage) 10 | pp Hoges::Hage.includes?(Hoges::Hoge) 11 | 12 | # => Hoges::Hoge.includes?(Hoges::Hoge) = false 13 | # => Hoges::Hoge.includes?(Hoges::Hage) = false 14 | # => Hoges::Hage.includes?(Hoges::Hage) = true 15 | # => Hoges::Hage.includes?(Hoges::Hoge) = false 16 | -------------------------------------------------------------------------------- /Enum/names.cr: -------------------------------------------------------------------------------- 1 | enum Hoges 2 | Hoge 3 | Hige 4 | Hage 5 | end 6 | 7 | pp Hoges.names 8 | 9 | # => Hoges.names = ["Hoge", "Hige", "Hage"] 10 | -------------------------------------------------------------------------------- /Enum/parse.cr: -------------------------------------------------------------------------------- 1 | enum Hoges 2 | Hoge 3 | Hige 4 | Hage 5 | end 6 | 7 | pp Hoges.parse("Hoge") 8 | pp Hoges.parse("Hige") 9 | pp Hoges.parse("Hage") 10 | 11 | # => Hoges.parse("Hoge") = Hoge 12 | # => Hoges.parse("Hige") = Hige 13 | # => Hoges.parse("Hage") = Hage 14 | -------------------------------------------------------------------------------- /Enum/parse_q.cr: -------------------------------------------------------------------------------- 1 | enum Hoges 2 | Hoge 3 | Hige 4 | Hage 5 | end 6 | 7 | pp Hoges.parse?("Hoge") 8 | pp Hoges.parse?("Hige") 9 | pp Hoges.parse?("Hage") 10 | pp Hoges.parse?("Fuge") 11 | 12 | # => Hoges.parse?("Hoge") = Hoge 13 | # => Hoges.parse?("Hige") = Hige 14 | # => Hoges.parse?("Hage") = Hage 15 | # => Hoges.parse?("Fuge") = nil 16 | -------------------------------------------------------------------------------- /Enum/pipe.cr: -------------------------------------------------------------------------------- 1 | enum TF 2 | True 3 | False 4 | end 5 | 6 | pp TF::True | TF::True 7 | pp TF::False | TF::True 8 | pp TF::True | TF::False 9 | pp TF::False | TF::False 10 | 11 | # => TF::True | TF::True = True 12 | # => TF::False | TF::True = False 13 | # => TF::True | TF::False = False 14 | # => TF::False | TF::False = False 15 | -------------------------------------------------------------------------------- /Enum/plus.cr: -------------------------------------------------------------------------------- 1 | enum TF 2 | True 3 | False 4 | end 5 | 6 | pp TF.new(0) + 1 7 | pp TF.new(1) + 1 8 | pp TF.new(0) + 1 9 | pp TF.new(1) + 1 10 | 11 | # => (TF.new(0)) + 1 = False 12 | # => (TF.new(1)) + 1 = 2 13 | # => (TF.new(0)) + 1 = False 14 | # => (TF.new(1)) + 1 = 2 15 | -------------------------------------------------------------------------------- /Enum/to_f32.cr: -------------------------------------------------------------------------------- 1 | enum Hoges 2 | Hoge 3 | Hige 4 | Hage 5 | end 6 | 7 | pp Hoges::Hoge.to_f32 8 | 9 | # => Hoges::Hoge.to_f32 = 0 10 | -------------------------------------------------------------------------------- /Enum/to_f64.cr: -------------------------------------------------------------------------------- 1 | enum Hoges 2 | Hoge 3 | Hige 4 | Hage 5 | end 6 | 7 | pp Hoges::Hoge.to_f64 8 | 9 | # => Hoges::Hoge.to_f64 = 0 10 | -------------------------------------------------------------------------------- /Enum/to_i.cr: -------------------------------------------------------------------------------- 1 | enum TF 2 | True 3 | False 4 | end 5 | 6 | pp TF::True.to_i 7 | pp TF::False.to_i 8 | 9 | # => TF::True.to_i = 0 10 | # => TF::False.to_i = 1 -------------------------------------------------------------------------------- /Enum/to_i16.cr: -------------------------------------------------------------------------------- 1 | enum TF 2 | True 3 | False 4 | end 5 | 6 | pp TF::True.to_i16 7 | pp TF::False.to_i16 8 | 9 | # => TF::True.to_i = 0 10 | # => TF::False.to_i = 1 -------------------------------------------------------------------------------- /Enum/to_i32.cr: -------------------------------------------------------------------------------- 1 | enum TF 2 | True 3 | False 4 | end 5 | 6 | pp TF::True.to_i32 7 | pp TF::False.to_i32 8 | 9 | # => TF::True.to_i32 = 0 10 | # => TF::False.to_i32 = 1 11 | -------------------------------------------------------------------------------- /Enum/to_i64.cr: -------------------------------------------------------------------------------- 1 | enum TF 2 | True 3 | False 4 | end 5 | 6 | pp TF::True.to_i64 7 | pp TF::False.to_i64 8 | 9 | # => TF::True.to_i64 = 0 10 | # => TF::False.to_i64 = 1 -------------------------------------------------------------------------------- /Enum/to_i8.cr: -------------------------------------------------------------------------------- 1 | enum TF 2 | True 3 | False 4 | end 5 | 6 | pp TF::True.to_i8 7 | pp TF::False.to_i8 8 | 9 | # => TF::True.to_i8 = 0 10 | # => TF::False.to_i8 = 1 -------------------------------------------------------------------------------- /Enum/to_s.cr: -------------------------------------------------------------------------------- 1 | enum TF 2 | True 3 | False 4 | end 5 | 6 | pp TF::True.to_s 7 | pp TF::False.to_s 8 | 9 | # => TF::True.to_s = "True" 10 | # => TF::False.to_s = "False" 11 | -------------------------------------------------------------------------------- /Enum/to_u16.cr: -------------------------------------------------------------------------------- 1 | enum TF 2 | True 3 | False 4 | end 5 | 6 | pp TF::True.to_u16 7 | pp TF::False.to_u16 8 | 9 | # => TF::True.to_u16 = 0 10 | # => TF::False.to_u16 = 1 11 | -------------------------------------------------------------------------------- /Enum/to_u32.cr: -------------------------------------------------------------------------------- 1 | enum TF 2 | True 3 | False 4 | end 5 | 6 | pp TF::True.to_u32 7 | pp TF::False.to_u32 8 | 9 | # => TF::True.to_u32 = 0 10 | # => TF::False.to_u32 = 1 11 | -------------------------------------------------------------------------------- /Enum/to_u64.cr: -------------------------------------------------------------------------------- 1 | enum TF 2 | True 3 | False 4 | end 5 | 6 | pp TF::True.to_u64 7 | pp TF::False.to_u64 8 | 9 | # => TF::True.to_u64 = 0 10 | # => TF::False.to_u64 = 1 -------------------------------------------------------------------------------- /Enum/to_u8.cr: -------------------------------------------------------------------------------- 1 | enum TF 2 | True 3 | False 4 | end 5 | 6 | pp TF::True.to_u8 7 | pp TF::False.to_u8 8 | 9 | # => TF::True.to_u8 = 0 10 | # => TF::False.to_u8 = 1 -------------------------------------------------------------------------------- /Enum/values.cr: -------------------------------------------------------------------------------- 1 | enum Hoges 2 | Hoge 3 | Hige 4 | Hage 5 | end 6 | 7 | pp Hoges.values 8 | 9 | # => Hoges.values = [Hoge, Hige, Hage] 10 | -------------------------------------------------------------------------------- /Enum/xor.cr: -------------------------------------------------------------------------------- 1 | enum Hoges 2 | Hoge 3 | Hige 4 | Hage 5 | end 6 | 7 | pp Hoges::Hoge == Hoges::Hoge 8 | pp Hoges::Hoge == Hoges::Hage 9 | 10 | # => Hoges::Hoge == Hoges::Hoge = true 11 | # => Hoges::Hoge == Hoges::Hage = false 12 | -------------------------------------------------------------------------------- /Enumerable/all_q.cr: -------------------------------------------------------------------------------- 1 | class Fibonacci 2 | include Enumerable(Int32) 3 | 4 | def each 5 | a, b = 0, 1 6 | loop do 7 | yield b 8 | a, b = b, a + b 9 | end 10 | end 11 | end 12 | 13 | fib = Fibonacci.new 14 | pp fib.take(10) 15 | pp fib.take(10).all? { |x| x < 55 } 16 | pp fib.take(10).all? { |x| x < 56 } 17 | 18 | # => fib.take(10) = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55] 19 | # => (fib.take(10)).all?(&.<(55)) = false 20 | # => (fib.take(10)).all?(&.<(56)) = true 21 | -------------------------------------------------------------------------------- /Enumerable/any_q.cr: -------------------------------------------------------------------------------- 1 | class Fibonacci 2 | include Enumerable(Int32) 3 | 4 | def each 5 | a, b = 0, 1 6 | loop do 7 | yield b 8 | a, b = b, a + b 9 | end 10 | end 11 | end 12 | 13 | fib = Fibonacci.new 14 | pp fib.take(10) 15 | pp fib.take(10).any? { |x| x.odd? } 16 | pp fib.take(10).all? { |x| x.even? } 17 | 18 | # => fib.take(10) = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55] 19 | # => (fib.take(10)).any?(&.odd?) = true 20 | # => (fib.take(10)).all?(&.even?) = false 21 | 22 | -------------------------------------------------------------------------------- /Enumerable/compact_map.cr: -------------------------------------------------------------------------------- 1 | pp ["Hoge", "Hoge", "Bar"].map { |name| name.match(/H/) } 2 | pp ["Hoge", "Hoge", "Bar"].compact_map { |name| name.match(/H/) } 3 | 4 | # => ["Hoge", "Hoge", "Bar"].map(&.match(/H/)) = [#, #, nil] 5 | # => ["Hoge", "Hoge", "Bar"].compact_map(&.match(/H/)) = [#, #] 6 | -------------------------------------------------------------------------------- /Enumerable/count.cr: -------------------------------------------------------------------------------- 1 | class Fibonacci 2 | include Enumerable(Int32) 3 | 4 | def each 5 | a, b = 0, 1 6 | loop do 7 | yield b 8 | a, b = b, a + b 9 | end 10 | end 11 | end 12 | 13 | fib = Fibonacci.new 14 | pp fib.take(10) 15 | pp fib.take(10).count(1) 16 | pp fib.take(10).count(2) 17 | 18 | # => fib.take(10) = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55] 19 | # => (fib.take(10)).count(1) = 2 20 | # => (fib.take(10)).count(2) = 1 21 | -------------------------------------------------------------------------------- /Enumerable/each.cr: -------------------------------------------------------------------------------- 1 | class Fibonacci 2 | include Enumerable(Int32) 3 | 4 | def each 5 | a, b = 0, 1 6 | loop do 7 | yield b 8 | a, b = b, a + b 9 | end 10 | end 11 | end 12 | 13 | fib = Fibonacci.new 14 | fib.take(10).each {|e|pp "#{e + 1}"} 15 | fib.take(5).each {|e|pp "#{e.odd?}"} 16 | 17 | # => "#{e + 1}" = "2" 18 | # => "#{e + 1}" = "2" 19 | # => "#{e + 1}" = "3" 20 | # => "#{e + 1}" = "4" 21 | # => "#{e + 1}" = "6" 22 | # => "#{e + 1}" = "9" 23 | # => "#{e + 1}" = "14" 24 | # => "#{e + 1}" = "22" 25 | # => "#{e + 1}" = "35" 26 | # => "#{e + 1}" = "56" 27 | # => "#{e.odd?}" = "true" 28 | # => "#{e.odd?}" = "true" 29 | # => "#{e.odd?}" = "false" 30 | # => "#{e.odd?}" = "true" 31 | # => "#{e.odd?}" = "true" 32 | -------------------------------------------------------------------------------- /Enumerable/each_cons.cr: -------------------------------------------------------------------------------- 1 | class Fibonacci 2 | include Enumerable(Int32) 3 | 4 | def each 5 | a, b = 0, 1 6 | loop do 7 | yield b 8 | a, b = b, a + b 9 | end 10 | end 11 | end 12 | 13 | fib = Fibonacci.new 14 | fib.take(10).each_cons(2) {|e|pp e} 15 | 16 | # => e = [1, 1] 17 | # => e = [1, 2] 18 | # => e = [2, 3] 19 | # => e = [3, 5] 20 | # => e = [5, 8] 21 | # => e = [8, 13] 22 | # => e = [13, 21] 23 | # => e = [21, 34] 24 | # => e = [34, 55] 25 | -------------------------------------------------------------------------------- /Enumerable/each_slice.cr: -------------------------------------------------------------------------------- 1 | class Fibonacci 2 | include Enumerable(Int32) 3 | 4 | def each 5 | a, b = 0, 1 6 | loop do 7 | yield b 8 | a, b = b, a + b 9 | end 10 | end 11 | end 12 | 13 | fib = Fibonacci.new 14 | fib.take(10).each_slice(2) {|e|pp e} 15 | 16 | # => e = [1, 1] 17 | # => e = [2, 3] 18 | # => e = [5, 8] 19 | # => e = [13, 21] 20 | # => e = [34, 55] 21 | 22 | -------------------------------------------------------------------------------- /Enumerable/each_with_index.cr: -------------------------------------------------------------------------------- 1 | class Fibonacci 2 | include Enumerable(Int32) 3 | 4 | def each 5 | a, b = 0, 1 6 | loop do 7 | yield b 8 | a, b = b, a + b 9 | end 10 | end 11 | end 12 | 13 | fib = Fibonacci.new 14 | fib.take(10).each_with_index {|e, i|pp "#{i}: #{e}"} 15 | 16 | # => "#{i}: #{e}" = "0: 1" 17 | # => "#{i}: #{e}" = "1: 1" 18 | # => "#{i}: #{e}" = "2: 2" 19 | # => "#{i}: #{e}" = "3: 3" 20 | # => "#{i}: #{e}" = "4: 5" 21 | # => "#{i}: #{e}" = "5: 8" 22 | # => "#{i}: #{e}" = "6: 13" 23 | # => "#{i}: #{e}" = "7: 21" 24 | # => "#{i}: #{e}" = "8: 34" 25 | # => "#{i}: #{e}" = "9: 55" 26 | -------------------------------------------------------------------------------- /Enumerable/each_with_object.cr: -------------------------------------------------------------------------------- 1 | class Fibonacci 2 | include Enumerable(Int32) 3 | 4 | def each 5 | a, b = 0, 1 6 | loop do 7 | yield b 8 | a, b = b, a + b 9 | end 10 | end 11 | end 12 | 13 | fib = Fibonacci.new 14 | pp fib.take(10).each_with_object(Array(Int32).new) {|e, memo|memo << e + 1} 15 | pp fib.take(5).each_with_object(Array(Int32).new) {|e, memo|memo << e + 2} 16 | 17 | # => (fib.take(10)).each_with_object(Array(Int32).new) do |e, memo| 18 | # => memo << e + 1 19 | # => end = [2, 2, 3, 4, 6, 9, 14, 22, 35, 56] 20 | # => (fib.take(5)).each_with_object(Array(Int32).new) do |e, memo| 21 | # => memo << e + 2 22 | # => end = [3, 3, 4, 5, 7] 23 | -------------------------------------------------------------------------------- /Enumerable/find.cr: -------------------------------------------------------------------------------- 1 | class Fibonacci 2 | include Enumerable(Int32) 3 | 4 | def each 5 | a, b = 0, 1 6 | loop do 7 | yield b 8 | a, b = b, a + b 9 | end 10 | end 11 | end 12 | 13 | fib = Fibonacci.new 14 | pp fib.take(10).find{ |e|e > 13 } 15 | pp fib.take(5).find{ |e|e.odd? } 16 | 17 | # => (fib.take(10)).find(&.>(13)) = 21 18 | # => (fib.take(5)).find(&.odd?) = 1 -------------------------------------------------------------------------------- /Enumerable/first.cr: -------------------------------------------------------------------------------- 1 | class Fibonacci 2 | include Enumerable(Int32) 3 | 4 | def each 5 | a, b = 0, 1 6 | loop do 7 | yield b 8 | a, b = b, a + b 9 | end 10 | end 11 | end 12 | 13 | fib = Fibonacci.new 14 | pp fib.take(10).first 15 | pp fib.take(5).first 16 | 17 | # => (fib.take(10)).first = 1 18 | # => (fib.take(5)).first = 1 -------------------------------------------------------------------------------- /Enumerable/first_q.cr: -------------------------------------------------------------------------------- 1 | class Fibonacci 2 | include Enumerable(Int32) 3 | 4 | def each 5 | a, b = 0, 1 6 | loop do 7 | yield b 8 | a, b = b, a + b 9 | end 10 | end 11 | end 12 | 13 | fib = Fibonacci.new 14 | pp fib.take(5).first? 15 | pp fib.take(0).first? 16 | 17 | # => (fib.take(5)).first? = 1 18 | # => (fib.take(0)).first? = nil -------------------------------------------------------------------------------- /Enumerable/flat_map.cr: -------------------------------------------------------------------------------- 1 | pp ["tanaka,seiji", "kudo,sinichi"].flat_map { |user|user.split(",") } 2 | 3 | # => ["tanaka,seiji", "kudo,sinichi"].flat_map(&.split(",")) = ["tanaka", "seiji", "kudo", "sinichi"] 4 | -------------------------------------------------------------------------------- /Enumerable/grep.cr: -------------------------------------------------------------------------------- 1 | pp ["hoge", "hige", "hage", "hoo", "bar"].grep(/h.+/) 2 | pp ["hoge", "hige", "hage", "hoo", "bar"].grep(/g/) 3 | 4 | # => ["hoge", "hige", "hage", "hoo", "bar"].grep(/h.+/) = ["hoge", "hige", "hage", "hoo"] 5 | # => ["hoge", "hige", "hage", "hoo", "bar"].grep(/g/) = ["hoge", "hige", "hage"] 6 | -------------------------------------------------------------------------------- /Enumerable/group_by.cr: -------------------------------------------------------------------------------- 1 | class Fibonacci 2 | include Enumerable(Int32) 3 | 4 | def each 5 | a, b = 0, 1 6 | loop do 7 | yield b 8 | a, b = b, a + b 9 | end 10 | end 11 | end 12 | 13 | fib = Fibonacci.new 14 | pp fib.take(10).group_by{|e|e.odd?} 15 | pp fib.take(5).first 16 | 17 | # => (fib.take(10)).group_by(&.odd?) = {true => [1, 1, 3, 5, 13, 21, 55], false => [2, 8, 34]} 18 | -------------------------------------------------------------------------------- /Enumerable/includes.cr: -------------------------------------------------------------------------------- 1 | class Fibonacci 2 | include Enumerable(Int32) 3 | 4 | def each 5 | a, b = 0, 1 6 | loop do 7 | yield b 8 | a, b = b, a + b 9 | end 10 | end 11 | end 12 | 13 | fib = Fibonacci.new 14 | pp fib.take(10) 15 | pp fib.take(10).includes?(55) 16 | pp fib.take(10).includes?(4) 17 | 18 | # => fib.take(10) = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55] 19 | # => (fib.take(10)).includes?(55) = true 20 | # => (fib.take(10)).includes?(4) = false 21 | -------------------------------------------------------------------------------- /Enumerable/index.cr: -------------------------------------------------------------------------------- 1 | class Fibonacci 2 | include Enumerable(Int32) 3 | 4 | def each 5 | a, b = 0, 1 6 | loop do 7 | yield b 8 | a, b = b, a + b 9 | end 10 | end 11 | end 12 | 13 | fib = Fibonacci.new 14 | pp fib.take(10).index(5) 15 | pp fib.take(10).index {|e|e > 13} 16 | pp fib.take(10).index {|e|e.even?} 17 | 18 | # => (fib.take(10)).index(5) = 4 19 | # => (fib.take(10)).index(&.>(13)) = 7 20 | # => (fib.take(10)).index(&.even?) = 2 21 | -------------------------------------------------------------------------------- /Enumerable/index_by.cr: -------------------------------------------------------------------------------- 1 | class Fibonacci 2 | include Enumerable(Int32) 3 | 4 | def each 5 | a, b = 0, 1 6 | loop do 7 | yield b 8 | a, b = b, a + b 9 | end 10 | end 11 | end 12 | 13 | fib = Fibonacci.new 14 | pp fib.take(10).index_by {|e|e.odd? } 15 | pp fib.take(10).index_by(&.odd?) 16 | pp fib.take(10).index_by {|e|e > 13 } 17 | 18 | # => (fib.take(10)).index_by(&.odd?) = {true => 55, false => 34} 19 | # => (fib.take(10)).index_by(&.odd?) = {true => 55, false => 34} 20 | # => (fib.take(10)).index_by(&.>(13)) = {false => 13, true => 55} 21 | -------------------------------------------------------------------------------- /Enumerable/join.cr: -------------------------------------------------------------------------------- 1 | class Fibonacci 2 | include Enumerable(Int32) 3 | 4 | def each 5 | a, b = 0, 1 6 | loop do 7 | yield b 8 | a, b = b, a + b 9 | end 10 | end 11 | end 12 | 13 | fib = Fibonacci.new 14 | pp fib.take(10).join("|") 15 | fib.take(10).join("|", STDOUT) { |i, io| io << "#{i + 1}" } 16 | puts 17 | pp fib.take(10).join("|") { |i| "#{i + 2}" } 18 | 19 | # => (fib.take(10)).join("|") = "1|1|2|3|5|8|13|21|34|55" 20 | # => 2|2|3|4|6|9|14|22|35|56 21 | # => (fib.take(10)).join("|") do |i| 22 | # => "#{i + 2}" 23 | # => end = "3|3|4|5|7|10|15|23|36|57" 24 | -------------------------------------------------------------------------------- /Enumerable/map.cr: -------------------------------------------------------------------------------- 1 | class Fibonacci 2 | include Enumerable(Int32) 3 | 4 | def each 5 | a, b = 0, 1 6 | loop do 7 | yield b 8 | a, b = b, a + b 9 | end 10 | end 11 | end 12 | 13 | fib = Fibonacci.new 14 | pp fib.take(10).map(&.+(1)) 15 | pp fib.take(10).map{|e|e+1} 16 | 17 | # => (fib.take(10)).map(&.+(1)) = [2, 2, 3, 4, 6, 9, 14, 22, 35, 56] 18 | # => (fib.take(10)).map(&.+(1)) = [2, 2, 3, 4, 6, 9, 14, 22, 35, 56] 19 | -------------------------------------------------------------------------------- /Enumerable/map_with_index.cr: -------------------------------------------------------------------------------- 1 | class Fibonacci 2 | include Enumerable(Int32) 3 | 4 | def each 5 | a, b = 0, 1 6 | loop do 7 | yield b 8 | a, b = b, a + b 9 | end 10 | end 11 | end 12 | 13 | fib = Fibonacci.new 14 | puts fib.take(10).map_with_index{|e, i|"#{i}: #{e}"} 15 | 16 | # => ["0: 1", "1: 1", "2: 2", "3: 3", "4: 5", "5: 8", "6: 13", "7: 21", "8: 34", "9: 55"] 17 | -------------------------------------------------------------------------------- /Enumerable/max.cr: -------------------------------------------------------------------------------- 1 | class Fibonacci 2 | include Enumerable(Int32) 3 | 4 | def each 5 | a, b = 0, 1 6 | loop do 7 | yield b 8 | a, b = b, a + b 9 | end 10 | end 11 | end 12 | 13 | fib = Fibonacci.new 14 | pp fib.take(10).max 15 | pp fib.take(5).max 16 | 17 | # => (fib.take(10)).max = 55 18 | # => (fib.take(5)).max = 5 19 | -------------------------------------------------------------------------------- /Enumerable/max_by.cr: -------------------------------------------------------------------------------- 1 | class Fibonacci 2 | include Enumerable(Int32) 3 | 4 | def each 5 | a, b = 0, 1 6 | loop do 7 | yield b 8 | a, b = b, a + b 9 | end 10 | end 11 | end 12 | 13 | fib = Fibonacci.new 14 | pp fib.take(10).max_by{|e|e%5} 15 | pp fib.take(5).max 16 | 17 | # => [1, 1, 2, 3, 5, 8, 13, 21, 34, 55] 18 | # => 34 19 | -------------------------------------------------------------------------------- /Enumerable/max_of: -------------------------------------------------------------------------------- 1 | class Fibonacci 2 | include Enumerable(Int32) 3 | 4 | def each 5 | a, b = 0, 1 6 | loop do 7 | yield b 8 | a, b = b, a + b 9 | end 10 | end 11 | end 12 | 13 | fib = Fibonacci.new 14 | puts fib.take(10).max_of{|e|e%5} 15 | 16 | # => 4 17 | -------------------------------------------------------------------------------- /Enumerable/max_q.cr: -------------------------------------------------------------------------------- 1 | class Fibonacci 2 | include Enumerable(Int32) 3 | 4 | def each 5 | a, b = 0, 1 6 | loop do 7 | yield b 8 | a, b = b, a + b 9 | end 10 | end 11 | end 12 | 13 | fib = Fibonacci.new 14 | puts fib.take(10).max? 15 | puts fib.take(5).max? 16 | puts fib.take(0).max?.class 17 | 18 | # => 55 19 | # => 5 20 | # => Nil 21 | -------------------------------------------------------------------------------- /Enumerable/min.cr: -------------------------------------------------------------------------------- 1 | class Fibonacci 2 | include Enumerable(Int32) 3 | 4 | def each 5 | a, b = 0, 1 6 | loop do 7 | yield b 8 | a, b = b, a + b 9 | end 10 | end 11 | end 12 | 13 | fib = Fibonacci.new 14 | pp fib.take(10).min 15 | pp fib.take(5).min 16 | 17 | # => (fib.take(10)).min = 1 18 | # => (fib.take(5)).min = 1 19 | -------------------------------------------------------------------------------- /Enumerable/min_by.cr: -------------------------------------------------------------------------------- 1 | class Fibonacci 2 | include Enumerable(Int32) 3 | 4 | def each 5 | a, b = 0, 1 6 | loop do 7 | yield b 8 | a, b = b, a + b 9 | end 10 | end 11 | end 12 | 13 | fib = Fibonacci.new 14 | print fib.take(10).min_by{|e|e%5}, "\n" 15 | print fib.take(5).min, "\n" 16 | 17 | # => 5 18 | # => 1 19 | -------------------------------------------------------------------------------- /Enumerable/min_of.cr: -------------------------------------------------------------------------------- 1 | class Fibonacci 2 | include Enumerable(Int32) 3 | 4 | def each 5 | a, b = 0, 1 6 | loop do 7 | yield b 8 | a, b = b, a + b 9 | end 10 | end 11 | end 12 | 13 | fib = Fibonacci.new 14 | puts fib.take(10).min_of{|e|e%5} 15 | 16 | # => 0 17 | -------------------------------------------------------------------------------- /Enumerable/min_of_q.cr: -------------------------------------------------------------------------------- 1 | class Fibonacci 2 | include Enumerable(Int32) 3 | 4 | def each 5 | a, b = 0, 1 6 | loop do 7 | yield b 8 | a, b = b, a + b 9 | end 10 | end 11 | end 12 | 13 | fib = Fibonacci.new 14 | puts fib.take(10).min_of?{|e|e%5} 15 | puts fib.take(0).min_of?{|e|e%5}.class 16 | 17 | # => 0 18 | # => Nil 19 | -------------------------------------------------------------------------------- /Enumerable/min_q.cr: -------------------------------------------------------------------------------- 1 | class Fibonacci 2 | include Enumerable(Int32) 3 | 4 | def each 5 | a, b = 0, 1 6 | loop do 7 | yield b 8 | a, b = b, a + b 9 | end 10 | end 11 | end 12 | 13 | fib = Fibonacci.new 14 | pp fib.take(5).min? 15 | pp fib.take(0).min? 16 | 17 | # => (fib.take(5)).min? = 1 18 | # => (fib.take(0)).min? = nil 19 | -------------------------------------------------------------------------------- /Enumerable/minmax.cr: -------------------------------------------------------------------------------- 1 | class Fibonacci 2 | include Enumerable(Int32) 3 | 4 | def each 5 | a, b = 0, 1 6 | loop do 7 | yield b 8 | a, b = b, a + b 9 | end 10 | end 11 | end 12 | 13 | fib = Fibonacci.new 14 | pp fib.take(5).minmax 15 | pp fib.take(10).minmax 16 | 17 | # => (fib.take(5)).minmax = {1, 5} 18 | # => (fib.take(10)).minmax = {1, 55} 19 | -------------------------------------------------------------------------------- /Enumerable/minmax_by.cr: -------------------------------------------------------------------------------- 1 | class Fibonacci 2 | include Enumerable(Int32) 3 | 4 | def each 5 | a, b = 0, 1 6 | loop do 7 | yield b 8 | a, b = b, a + b 9 | end 10 | end 11 | end 12 | 13 | fib = Fibonacci.new 14 | print fib.take(10).minmax_by{|e|e%5}, "\n" 15 | print fib.take(5).minmax_by{|e|e%5}, "\n" 16 | 17 | # => {5, 34} 18 | # => {5, 3} 19 | -------------------------------------------------------------------------------- /Enumerable/minmax_of.cr: -------------------------------------------------------------------------------- 1 | class Fibonacci 2 | include Enumerable(Int32) 3 | 4 | def each 5 | a, b = 0, 1 6 | loop do 7 | yield b 8 | a, b = b, a + b 9 | end 10 | end 11 | end 12 | 13 | fib = Fibonacci.new 14 | print fib.take(10).minmax_of{|e|e%5}, "\n" 15 | print fib.take(5).minmax_of{|e|e%5}, "\n" 16 | 17 | # => {0, 4} 18 | # => {0, 3} 19 | -------------------------------------------------------------------------------- /Enumerable/none_q.cr: -------------------------------------------------------------------------------- 1 | pp [nil, nil].none? 2 | pp [false, false].none? 3 | pp [true, true].none? 4 | 5 | # => [nil, nil].none? = true 6 | # => [false, false].none? = true 7 | # => [true, true].none? = false 8 | -------------------------------------------------------------------------------- /Enumerable/one.cr: -------------------------------------------------------------------------------- 1 | class Fibonacci 2 | include Enumerable(Int32) 3 | 4 | def each 5 | a, b = 0, 1 6 | loop do 7 | yield b 8 | a, b = b, a + b 9 | end 10 | end 11 | end 12 | 13 | fib = Fibonacci.new 14 | pp fib.take(1).one?{|e|e.odd?} 15 | pp fib.take(2).one?{|e|e.odd?} 16 | 17 | # => (fib.take(1)).one?(&.odd?) = true 18 | # => (fib.take(2)).one?(&.odd?) = false 19 | -------------------------------------------------------------------------------- /Enumerable/partition.cr: -------------------------------------------------------------------------------- 1 | class Fibonacci 2 | include Enumerable(Int32) 3 | 4 | def each 5 | a, b = 0, 1 6 | loop do 7 | yield b 8 | a, b = b, a + b 9 | end 10 | end 11 | end 12 | 13 | fib = Fibonacci.new 14 | pp fib.take(10).partition{|e|e.odd?} 15 | pp fib.take(10).partition{|e|e > 10} 16 | 17 | # => (fib.take(10)).partition(&.odd?) = {[1, 1, 3, 5, 13, 21, 55], [2, 8, 34]} 18 | # => (fib.take(10)).partition(&.>(10)) = {[13, 21, 34, 55], [1, 1, 2, 3, 5, 8]} 19 | -------------------------------------------------------------------------------- /Enumerable/reject.cr: -------------------------------------------------------------------------------- 1 | class Fibonacci 2 | include Enumerable(Int32) 3 | 4 | def each 5 | a, b = 0, 1 6 | loop do 7 | yield b 8 | a, b = b, a + b 9 | end 10 | end 11 | end 12 | 13 | fib = Fibonacci.new 14 | puts fib.take(20).reject{|e|e%5 == 0} 15 | puts fib.take(20).reject{|e|e%4 == 0} 16 | 17 | # => [1, 1, 2, 3, 8, 13, 21, 34, 89, 144, 233, 377, 987, 1597, 2584, 4181] 18 | # => [1, 1, 2, 3, 5, 13, 21, 34, 55, 89, 233, 377, 610, 987, 1597, 4181, 6765] 19 | -------------------------------------------------------------------------------- /Enumerable/select.cr: -------------------------------------------------------------------------------- 1 | class Fibonacci 2 | include Enumerable(Int32) 3 | 4 | def each 5 | a, b = 0, 1 6 | loop do 7 | yield b 8 | a, b = b, a + b 9 | end 10 | end 11 | end 12 | 13 | fib = Fibonacci.new 14 | puts fib.take(20).select{|e|e%5 == 0} 15 | puts fib.take(20).select{|e|e%4 == 0} 16 | 17 | # => [5, 55, 610, 6765] 18 | # => [8, 144, 2584] 19 | -------------------------------------------------------------------------------- /Enumerable/size.cr: -------------------------------------------------------------------------------- 1 | class Fibonacci 2 | include Enumerable(Int32) 3 | 4 | def each 5 | a, b = 0, 1 6 | loop do 7 | yield b 8 | a, b = b, a + b 9 | end 10 | end 11 | end 12 | 13 | fib = Fibonacci.new 14 | puts fib.take(20).size 15 | puts fib.take(10).size 16 | 17 | # => 20 18 | # => 10 19 | -------------------------------------------------------------------------------- /Enumerable/skip.cr: -------------------------------------------------------------------------------- 1 | class Fibonacci 2 | include Enumerable(Int32) 3 | 4 | def each 5 | a, b = 0, 1 6 | loop do 7 | yield b 8 | a, b = b, a + b 9 | end 10 | end 11 | end 12 | 13 | fib = Fibonacci.new 14 | puts fib.take(20).skip(10) 15 | puts fib.take(10).skip(5) 16 | 17 | # => [89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765] 18 | # => [8, 13, 21, 34, 55] 19 | -------------------------------------------------------------------------------- /Enumerable/skip_while.cr: -------------------------------------------------------------------------------- 1 | class Fibonacci 2 | include Enumerable(Int32) 3 | 4 | def each 5 | a, b = 0, 1 6 | loop do 7 | yield b 8 | a, b = b, a + b 9 | end 10 | end 11 | end 12 | 13 | fib = Fibonacci.new 14 | puts fib.take(20).skip_while{|e|e < 55} 15 | puts fib.take(10).skip_while{|e|e < 21} 16 | 17 | # => [55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765] 18 | # => [21, 34, 55] 19 | 20 | -------------------------------------------------------------------------------- /Enumerable/sum.cr: -------------------------------------------------------------------------------- 1 | class Fibonacci 2 | include Enumerable(Int32) 3 | 4 | def each 5 | a, b = 0, 1 6 | loop do 7 | yield b 8 | a, b = b, a + b 9 | end 10 | end 11 | end 12 | 13 | fib = Fibonacci.new 14 | pp fib.take(5) 15 | pp fib.take(5).sum 16 | pp fib.take(5).sum(1) 17 | pp fib.take(5).sum(1) {|e|e*2} 18 | 19 | # => fib.take(5) = [1, 1, 2, 3, 5] 20 | # => (fib.take(5)).sum = 12 21 | # => (fib.take(5)).sum(1) = 13 22 | # => (fib.take(5)).sum(1, &.*(2)) = 25 23 | -------------------------------------------------------------------------------- /Enumerable/take.cr: -------------------------------------------------------------------------------- 1 | class Fibonacci 2 | include Enumerable(Int32) 3 | 4 | def each 5 | a, b = 0, 1 6 | loop do 7 | yield b 8 | a, b = b, a + b 9 | end 10 | end 11 | end 12 | 13 | fib = Fibonacci.new 14 | puts fib.take(20) 15 | puts fib.take(10) 16 | 17 | # => [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765] 18 | # => [1, 1, 2, 3, 5, 8, 13, 21, 34, 55] 19 | -------------------------------------------------------------------------------- /Enumerable/take_while.cr: -------------------------------------------------------------------------------- 1 | class Fibonacci 2 | include Enumerable(Int32) 3 | 4 | def each 5 | a, b = 0, 1 6 | loop do 7 | yield b 8 | a, b = b, a + b 9 | end 10 | end 11 | end 12 | 13 | fib = Fibonacci.new 14 | puts fib.take_while {|e|e < 100} 15 | puts fib.take_while {|e|e.odd?} 16 | 17 | # => [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89] 18 | # => [1, 1] 19 | -------------------------------------------------------------------------------- /Enumerable/to_a.cr: -------------------------------------------------------------------------------- 1 | class ABC 2 | include Enumerable(String) 3 | 4 | def each 5 | yield "a" 6 | yield "b" 7 | yield "c" 8 | end 9 | end 10 | 11 | abc = ABC.new 12 | puts abc.class 13 | puts abc.to_a.class 14 | 15 | # => ABC 16 | # => Array(String) 17 | -------------------------------------------------------------------------------- /Enumerable/to_h.cr: -------------------------------------------------------------------------------- 1 | pp [[:hoge, "ほげ"], [:hige, "ひげ"]].to_h 2 | # [[:hoge, "ほげ"], [:hige, "ひげ"]].to_h = {:hoge => "ほげ", :hige => "ひげ"} 3 | -------------------------------------------------------------------------------- /Enumerable/to_set.cr: -------------------------------------------------------------------------------- 1 | pp [[:hoge, "ほげ"], [:hige, "ひげ"]].to_set 2 | # [[:hoge, "ほげ"], [:hige, "ひげ"]].to_set = Set{[:hoge, "ほげ"], [:hige, "ひげ"]} 3 | -------------------------------------------------------------------------------- /Exception/backtrace.cr: -------------------------------------------------------------------------------- 1 | begin 2 | raise "test" 3 | rescue e 4 | pp e.backtrace 5 | end 6 | 7 | # => e.backtrace = ["[134614889] *CallStack::unwind:Array(Pointer(Void)) +121", "[134614751] *CallStack#initialize:Array(Pointer(Void)) +31", "[134614693] *CallStack::new:CallStack +69", "[134623800] *Exception#initialize:CallStack +56", "[134623707] *Exception::new:Exception +139", "[134598834] *raise:NoReturn +34", "[134597889] ???", "[134606077] main +77", "[3074401431] __libc_start_main +247", "[134594801] ???"] 8 | -------------------------------------------------------------------------------- /Exception/cause.cr: -------------------------------------------------------------------------------- 1 | begin 2 | raise "test" 3 | rescue e 4 | pp e.cause 5 | end 6 | 7 | # => e.cause = nil 8 | -------------------------------------------------------------------------------- /Exception/inspect_with_backtrace.cr: -------------------------------------------------------------------------------- 1 | begin 2 | raise "test" 3 | rescue e 4 | puts e.inspect_with_backtrace 5 | end 6 | 7 | # => test (Exception) 8 | # => [134602633] *CallStack::unwind:Array(Pointer(Void)) +121 9 | # => [134602495] *CallStack#initialize:Array(Pointer(Void)) +31 10 | # => [134602437] *CallStack::new:CallStack +69 11 | # => [134610888] *Exception#initialize:CallStack +56 12 | # => [134610811] *Exception::new:Exception +139 13 | # => [134588194] *raise:NoReturn +34 14 | # => [134587374] ??? 15 | # => [134595453] main +77 16 | # => [3074462871] __libc_start_main +247 17 | # => [134584273] ??? 18 | -------------------------------------------------------------------------------- /Exception/message.cr: -------------------------------------------------------------------------------- 1 | begin 2 | raise "test" 3 | rescue e 4 | puts e.message 5 | end 6 | 7 | # => test 8 | -------------------------------------------------------------------------------- /Exception/to_s.cr: -------------------------------------------------------------------------------- 1 | begin 2 | raise "test" 3 | rescue e 4 | puts e.to_s 5 | end 6 | 7 | # => test 8 | -------------------------------------------------------------------------------- /Float/compare.cr: -------------------------------------------------------------------------------- 1 | pp 1.1 <=> 1.0 2 | pp 1.1 <=> 1.1 3 | pp 1.1 <=> 1.2 4 | 5 | # => 1.1 <=> 1.0 = 1 6 | # => 1.1 <=> 1.1 = 0 7 | # => 1.1 <=> 1.2 = -1 8 | -------------------------------------------------------------------------------- /Float/days.cr: -------------------------------------------------------------------------------- 1 | pp 1.0.days 2 | pp 1.1.days 3 | pp 1.5.days 4 | 5 | # => 1.0.days = 1.00:00:00 6 | # => 1.1.days = 1.02:24:00 7 | # => 1.5.days = 1.12:00:00 8 | -------------------------------------------------------------------------------- /Float/fdiv.cr: -------------------------------------------------------------------------------- 1 | pp 1.0.fdiv(1.0) 2 | pp 2.0.fdiv(1.0) 3 | pp 4.5.fdiv(1.5) 4 | 5 | # => 1.0.fdiv(1.0) = 1 6 | # => 2.0.fdiv(1.0) = 2 7 | # => 4.5.fdiv(1.5) = 3 8 | -------------------------------------------------------------------------------- /Float/finite.cr: -------------------------------------------------------------------------------- 1 | pp 1.0.finite? 2 | pp (1.0/0.0).finite? 3 | 4 | # => 1.0.finite? = true 5 | # => (1.0 / 0.0).finite? = false 6 | -------------------------------------------------------------------------------- /Float/hours.cr: -------------------------------------------------------------------------------- 1 | pp 1.1.hours 2 | pp 1.3.hours 3 | pp 1.5.hours 4 | 5 | # => 1.1.hours = 01:06:00 6 | # => 1.3.hours = 01:18:00 7 | # => 1.5.hours = 01:30:00 8 | -------------------------------------------------------------------------------- /Float/infinite.cr: -------------------------------------------------------------------------------- 1 | pp 1.0.infinite? 2 | pp (1.0/0.0).infinite? 3 | pp (-1.0/0.0).infinite? 4 | 5 | # => 1.0.infinite? = nil 6 | # => (1.0 / 0.0).infinite? = 1 7 | # => (-1.0 / 0.0).infinite? = -1 8 | -------------------------------------------------------------------------------- /Float/milliseconds.cr: -------------------------------------------------------------------------------- 1 | pp 1.1.milliseconds 2 | pp 1.3.milliseconds 3 | pp 1.5.milliseconds 4 | 5 | # => 1.1.milliseconds = 00:00:00.0010000 6 | # => 1.3.milliseconds = 00:00:00.0010000 7 | # => 1.5.milliseconds = 00:00:00.0020000 8 | -------------------------------------------------------------------------------- /Float/minutes.cr: -------------------------------------------------------------------------------- 1 | pp 1.0.minutes 2 | pp 1.1.minutes 3 | pp 1.5.minutes 4 | 5 | # => 1.0.minutes = 00:01:00 6 | # => 1.1.minutes = 00:01:06 7 | # => 1.5.minutes = 00:01:30 8 | -------------------------------------------------------------------------------- /Float/nan.cr: -------------------------------------------------------------------------------- 1 | pp (0.0/0.0).nan? 2 | pp 1.0.nan? 3 | 4 | # => (0.0 / 0.0).nan? = true 5 | # => 1.0.nan? = false 6 | -------------------------------------------------------------------------------- /Float/percent.cr: -------------------------------------------------------------------------------- 1 | pp 1.1%1 2 | # => 1.1 % 1 = 0.1 3 | -------------------------------------------------------------------------------- /Float/seconds.cr: -------------------------------------------------------------------------------- 1 | pp 1.0.seconds 2 | pp 1.3.seconds 3 | pp 1.5.seconds 4 | 5 | # => 1.0.seconds = 00:00:01 6 | # => 1.3.seconds = 00:00:01.3000000 7 | # => 1.5.seconds = 00:00:01.5000000 8 | -------------------------------------------------------------------------------- /Hash/all_q.cr: -------------------------------------------------------------------------------- 1 | hash = { 2 | key1: :value1, 3 | key2: :value2 4 | } 5 | 6 | puts hash.all? {|k, v|v.is_a?(Symbol) } 7 | puts hash.all? {|k, v|v.is_a?(String) } 8 | 9 | # => true 10 | # => false 11 | -------------------------------------------------------------------------------- /Hash/any_q.cr: -------------------------------------------------------------------------------- 1 | hash = { 2 | key1: :value1, 3 | key2: :value2 4 | } 5 | 6 | puts hash.any? {|k, v|v == :value1 } 7 | puts hash.any? {|k, v|v == :value3 } 8 | 9 | # => true 10 | # => false 11 | -------------------------------------------------------------------------------- /Hash/br.cr: -------------------------------------------------------------------------------- 1 | hash = { 2 | key1: :value1, 3 | key2: :value2 4 | } 5 | pp hash[:key1] 6 | pp hash[:key2] 7 | 8 | # => hash[:key1] = :value1 9 | # => hash[:key2] = :value2 10 | -------------------------------------------------------------------------------- /Hash/br_eq.cr: -------------------------------------------------------------------------------- 1 | hash = { 2 | key1: :value1, 3 | key2: :value2 4 | } 5 | 6 | pp hash 7 | hash[:key2] = :value2_update 8 | pp hash 9 | 10 | # => hash = {:key1 => :value1, :key2 => :value2} 11 | # => hash = {:key1 => :value1, :key2 => :value2_update} 12 | -------------------------------------------------------------------------------- /Hash/br_q.cr: -------------------------------------------------------------------------------- 1 | hash = { 2 | key1: :value1, 3 | key2: :value2 4 | } 5 | 6 | pp hash 7 | pp hash[:key2]? 8 | pp hash[:key3]? 9 | 10 | # => hash = {:key1 => :value1, :key2 => :value2} 11 | # => hash[:key2]? = :value2 12 | # => hash[:key3]? = nil 13 | -------------------------------------------------------------------------------- /Hash/clear.cr: -------------------------------------------------------------------------------- 1 | hash = { 2 | key1: :value1, 3 | key2: :value2 4 | } 5 | 6 | pp hash 7 | hash.clear 8 | pp hash 9 | 10 | # => hash = {:key1 => :value1, :key2 => :value2} 11 | # => hash = {} 12 | -------------------------------------------------------------------------------- /Hash/clone.cr: -------------------------------------------------------------------------------- 1 | hash = { 2 | key1: :value1, 3 | key2: :value2 4 | } 5 | 6 | pp hash 7 | hash_clone = hash.clone 8 | pp hash_clone 9 | pp hash == hash_clone 10 | hash_clone[:key1] = :value_change 11 | pp hash 12 | pp hash_clone 13 | 14 | # => hash = {:key1 => :value1, :key2 => :value2} 15 | # => hash_clone = {:key1 => :value1, :key2 => :value2} 16 | # => hash == hash_clone = true 17 | # => hash = {:key1 => :value1, :key2 => :value2} 18 | # => hash_clone = {:key1 => :value_change, :key2 => :value2} 19 | -------------------------------------------------------------------------------- /Hash/delete.cr: -------------------------------------------------------------------------------- 1 | hash = { 2 | key1: :value1, 3 | key2: :value2 4 | } 5 | 6 | pp hash 7 | hash.delete(:key2) 8 | pp hash 9 | 10 | # => hash = {:key1 => :value1, :key2 => :value2} 11 | # => hash = {:key1 => :value1} 12 | -------------------------------------------------------------------------------- /Hash/delete_if.cr: -------------------------------------------------------------------------------- 1 | hash = { 2 | key1: :value1, 3 | key2: :value2, 4 | hoge_key: :hoge_value 5 | } 6 | 7 | pp hash 8 | hash.delete_if { |key, value|key.to_s =~ /^key/ } 9 | pp hash 10 | 11 | # => hash = {:key1 => :value1, :key2 => :value2, :hoge_key => :hoge_value} 12 | # => hash = {:hoge_key => :hoge_value} 13 | -------------------------------------------------------------------------------- /Hash/dup.cr: -------------------------------------------------------------------------------- 1 | hash = { 2 | key1: :value1, 3 | key2: :value2, 4 | hoge_key: :hoge_value 5 | } 6 | 7 | pp hash 8 | dup_hash = hash.dup 9 | pp dup_hash 10 | dup_hash[:key3] = :value3 11 | pp hash 12 | pp dup_hash 13 | 14 | # => hash = {:key1 => :value1, :key2 => :value2, :hoge_key => :hoge_value} 15 | # => dup_hash = {:key1 => :value1, :key2 => :value2, :hoge_key => :hoge_value} 16 | # => hash = {:key1 => :value1, :key2 => :value2, :hoge_key => :hoge_value} 17 | # => dup_hash = {:key1 => :value1, :key2 => :value2, :hoge_key => :hoge_value, :key3 => :value3} 18 | -------------------------------------------------------------------------------- /Hash/each_with_index.cr: -------------------------------------------------------------------------------- 1 | hash = { 2 | key1: :value1, 3 | key2: :value2, 4 | hoge_key: :hoge_value 5 | } 6 | 7 | pp hash 8 | hash.each_with_index { |key, value, i|pp "#{i}: #{key} - #{value}"} 9 | hash.each_with_index(10) { |key, value, i|pp "#{i}: #{key} - #{value}"} 10 | 11 | # => hash = {:key1 => :value1, :key2 => :value2, :hoge_key => :hoge_value} 12 | # => "#{i}: #{key} - #{value}" = "0: key1 - value1" 13 | # => "#{i}: #{key} - #{value}" = "1: key2 - value2" 14 | # => "#{i}: #{key} - #{value}" = "2: hoge_key - hoge_value" 15 | # => "#{i}: #{key} - #{value}" = "10: key1 - value1" 16 | # => "#{i}: #{key} - #{value}" = "11: key2 - value2" 17 | # => "#{i}: #{key} - #{value}" = "12: hoge_key - hoge_value" 18 | -------------------------------------------------------------------------------- /Hash/each_with_object.cr: -------------------------------------------------------------------------------- 1 | hash = { 2 | key1: :value1, 3 | key2: :value2, 4 | hoge_key: :hoge_value 5 | } 6 | 7 | pp hash 8 | memo = hash.each_with_object([] of String) { |memo, key, value|memo << "#{key}:#{value}"} 9 | pp memo 10 | 11 | # => hash = {:key1 => :value1, :key2 => :value2, :hoge_key => :hoge_value} 12 | # => memo = ["key1:value1", "key2:value2", "hoge_key:hoge_value"] 13 | -------------------------------------------------------------------------------- /Hash/empty.cr: -------------------------------------------------------------------------------- 1 | hash = { 2 | key1: :value1, 3 | key2: :value2, 4 | hoge_key: :hoge_value 5 | } 6 | 7 | pp hash 8 | pp hash.empty? 9 | hash.clear 10 | pp hash 11 | pp hash.empty? 12 | 13 | # => hash = {:key1 => :value1, :key2 => :value2, :hoge_key => :hoge_value} 14 | # => hash.empty? = false 15 | # => hash = {} 16 | # => hash.empty? = true 17 | -------------------------------------------------------------------------------- /Hash/eq.cr: -------------------------------------------------------------------------------- 1 | hash = { key: :value } 2 | pp hash == { key: :value } 3 | pp hash == { key: :value1 } 4 | pp hash == { key1: :value } 5 | 6 | # => hash == {:key => :value} = true 7 | # => hash == {:key => :value1} = false 8 | # => hash == {:key1 => :value} = false 9 | -------------------------------------------------------------------------------- /Hash/fetch.cr: -------------------------------------------------------------------------------- 1 | hash = { 2 | key1: :value1, 3 | key2: :value2, 4 | hoge_key: :hoge_value 5 | } 6 | 7 | pp hash 8 | pp hash.fetch(:key1, :default) 9 | pp hash.fetch(:key3, :default) 10 | 11 | # => hash = {:key1 => :value1, :key2 => :value2, :hoge_key => :hoge_value} 12 | # => hash.fetch(:key1, :default) = :value1 13 | # => hash.fetch(:key3, :default) = :default 14 | -------------------------------------------------------------------------------- /Hash/first.cr: -------------------------------------------------------------------------------- 1 | hash = { 2 | key1: :value1, 3 | key2: :value2, 4 | hoge_key: :hoge_value 5 | } 6 | 7 | pp hash 8 | pp hash.first 9 | 10 | # => hash = {:key1 => :value1, :key2 => :value2, :hoge_key => :hoge_value} 11 | # => hash.first = {:key1, :value1} 12 | -------------------------------------------------------------------------------- /Hash/first_key.cr: -------------------------------------------------------------------------------- 1 | hash = { 2 | key1: :value1, 3 | key2: :value2, 4 | hoge_key: :hoge_value 5 | } 6 | 7 | pp hash 8 | pp hash.first_key 9 | 10 | # => hash = {:key1 => :value1, :key2 => :value2, :hoge_key => :hoge_value} 11 | # => hash.first_key = :key1 12 | -------------------------------------------------------------------------------- /Hash/has_key.cr: -------------------------------------------------------------------------------- 1 | hash = { 2 | key1: :value1, 3 | key2: :value2, 4 | hoge_key: :hoge_value 5 | } 6 | 7 | pp hash 8 | pp hash.has_key?(:key1) 9 | pp hash.has_key?(:key3) 10 | 11 | # => hash = {:key1 => :value1, :key2 => :value2, :hoge_key => :hoge_value} 12 | # => hash.has_key?(:key1) = true 13 | # => hash.has_key?(:key3) = false 14 | -------------------------------------------------------------------------------- /Hash/hash.cr: -------------------------------------------------------------------------------- 1 | hash = { 2 | key1: :value1, 3 | key2: :value2, 4 | hoge_key: :hoge_value 5 | } 6 | 7 | pp hash 8 | pp hash.hash 9 | 10 | # => hash = {:key1 => :value1, :key2 => :value2, :hoge_key => :hoge_value} 11 | # => hash.hash = 18 12 | -------------------------------------------------------------------------------- /Hash/invert.cr: -------------------------------------------------------------------------------- 1 | hash = { 2 | key1: :value1, 3 | key2: :value2, 4 | hoge_key: :hoge_value 5 | } 6 | 7 | pp hash 8 | pp hash.invert 9 | 10 | # => ash = {:key1 => :value1, :key2 => :value2, :hoge_key => :hoge_value} 11 | # => hash.invert = {:value1 => :key1, :value2 => :key2, :hoge_value => :hoge_key} 12 | -------------------------------------------------------------------------------- /Hash/key.cr: -------------------------------------------------------------------------------- 1 | hash = { 2 | key1: :value1, 3 | key2: :value2, 4 | hoge_key: :hoge_value 5 | } 6 | 7 | pp hash 8 | pp hash.key(:value1) 9 | 10 | # => hash = {:key1 => :value1, :key2 => :value2, :hoge_key => :hoge_value} 11 | # => hash.key(:value1) = :key1 12 | -------------------------------------------------------------------------------- /Hash/key_index.cr: -------------------------------------------------------------------------------- 1 | hash = { 2 | key1: :value1, 3 | key2: :value2, 4 | hoge_key: :hoge_value 5 | } 6 | 7 | pp hash 8 | pp hash.key_index(:key1) 9 | pp hash.key_index(:key2) 10 | 11 | # => hash = {:key1 => :value1, :key2 => :value2, :hoge_key => :hoge_value} 12 | # => hash.key_index(:key1) = 0 13 | # => hash.key_index(:key2) = 1 14 | -------------------------------------------------------------------------------- /Hash/key_q.cr: -------------------------------------------------------------------------------- 1 | hash = { 2 | key1: :value1, 3 | key2: :value2, 4 | hoge_key: :hoge_value 5 | } 6 | 7 | pp hash 8 | pp hash.key?(:value1) 9 | pp hash.key?(:value4) 10 | 11 | # => hash = {:key1 => :value1, :key2 => :value2, :hoge_key => :hoge_value} 12 | # => hash.key?(:value1) = :key1 13 | # => hash.key?(:value4) = nil 14 | -------------------------------------------------------------------------------- /Hash/keys.cr: -------------------------------------------------------------------------------- 1 | hash = { 2 | key1: :value1, 3 | key2: :value2, 4 | hoge_key: :hoge_value 5 | } 6 | 7 | pp hash 8 | pp hash.keys 9 | 10 | # => hash = {:key1 => :value1, :key2 => :value2, :hoge_key => :hoge_value} 11 | # => hash.keys = [:key1, :key2, :hoge_key] 12 | -------------------------------------------------------------------------------- /Hash/map.cr: -------------------------------------------------------------------------------- 1 | hash = { 2 | key1: :value1, 3 | key2: :value2, 4 | hoge_key: :hoge_value 5 | } 6 | 7 | pp hash 8 | pp hash.map{|e|e.to_s} 9 | pp hash.map{|e|e.to_s}.map(&.upcase) 10 | 11 | # => hash = {:key1 => :value1, :key2 => :value2, :hoge_key => :hoge_value} 12 | # => hash.map(&.to_s) = ["key1", "key2", "hoge_key"] 13 | # => hash.map(&.to_s).map(&.upcase) = ["KEY1", "KEY2", "HOGE_KEY"] 14 | -------------------------------------------------------------------------------- /Hash/merge.cr: -------------------------------------------------------------------------------- 1 | hash = { 2 | key1: :value1, 3 | key2: :value2, 4 | hoge_key: :hoge_value 5 | } 6 | 7 | pp hash 8 | pp hash.merge({key3: :value3}) 9 | pp hash.map{|e|e.to_s}.map(&.upcase) 10 | 11 | # => hash = {:key1 => :value1, :key2 => :value2, :hoge_key => :hoge_value} 12 | # => hash.merge({:key3 => :value3}) = {:key1 => :value1, :key2 => :value2, :hoge_key => :hoge_value, :key3 => :value3} 13 | -------------------------------------------------------------------------------- /Hash/reduce.cr: -------------------------------------------------------------------------------- 1 | hash = { 2 | key1: :value1, 3 | key2: :value2, 4 | hoge_key: :hoge_value 5 | } 6 | 7 | pp hash 8 | puts hash.reduce(Array(String).new){|a,key,value|a << key.to_s + value.to_s} 9 | 10 | # => hash = {:key1 => :value1, :key2 => :value2, :hoge_key => :hoge_value} 11 | # => ["key1value1", "key2value2", "hoge_keyhoge_value"] 12 | -------------------------------------------------------------------------------- /Hash/reject.cr: -------------------------------------------------------------------------------- 1 | hash = { 2 | key1: :value1, 3 | key2: :value2, 4 | hoge_key: :hoge_value 5 | } 6 | 7 | pp hash 8 | pp hash.reject(:key2, :hoge_key) 9 | pp hash 10 | pp hash.reject!(:key2, :hoge_key) 11 | pp hash 12 | 13 | # => hash = {:key1 => :value1, :key2 => :value2, :hoge_key => :hoge_value} 14 | # => hash.reject(:key2, :hoge_key) = {:key1 => :value1} 15 | # => hash = {:key1 => :value1, :key2 => :value2, :hoge_key => :hoge_value} 16 | # => hash.reject!(:key2, :hoge_key) = {:key1 => :value1} 17 | # => hash = {:key1 => :value1} 18 | -------------------------------------------------------------------------------- /Hash/select.cr: -------------------------------------------------------------------------------- 1 | hash = { 2 | key1: :value1, 3 | key2: :value2, 4 | hoge_key: :hoge_value 5 | } 6 | 7 | pp hash 8 | puts hash.select{|k, v|k.to_s =~ /key/} 9 | puts hash.select{|k, v|k.to_s =~ /hoge_key/} 10 | 11 | # => hash = {:key1 => :value1, :key2 => :value2, :hoge_key => :hoge_value} 12 | # => {:key1 => :value1, :key2 => :value2, :hoge_key => :hoge_value} 13 | # => {:hoge_key => :hoge_value} 14 | -------------------------------------------------------------------------------- /Hash/shift.cr: -------------------------------------------------------------------------------- 1 | hash = { 2 | key1: :value1, 3 | key2: :value2, 4 | hoge_key: :hoge_value 5 | } 6 | 7 | pp hash 8 | puts hash.shift 9 | puts hash 10 | puts hash.shift 11 | puts hash 12 | 13 | # => hash = {:key1 => :value1, :key2 => :value2, :hoge_key => :hoge_value} 14 | # => {:key1, :value1} 15 | # => {:key2 => :value2, :hoge_key => :hoge_value} 16 | # => {:key2, :value2} 17 | # => {:hoge_key => :hoge_value} 18 | -------------------------------------------------------------------------------- /Hash/size.cr: -------------------------------------------------------------------------------- 1 | hash = { 2 | key1: :value1, 3 | key2: :value2, 4 | hoge_key: :hoge_value 5 | } 6 | 7 | pp hash 8 | puts hash.size 9 | puts hash[:key3] = :value3 10 | puts hash.size 11 | 12 | # => hash = {:key1 => :value1, :key2 => :value2, :hoge_key => :hoge_value} 13 | # => 3 14 | # => value3 15 | # => 4 16 | -------------------------------------------------------------------------------- /Hash/to_a.cr: -------------------------------------------------------------------------------- 1 | hash = { 2 | key1: :value1, 3 | key2: :value2, 4 | hoge_key: :hoge_value 5 | } 6 | 7 | pp hash 8 | puts hash.to_a 9 | 10 | # => hash = {:key1 => :value1, :key2 => :value2, :hoge_key => :hoge_value} 11 | # => [{:key1, :value1}, {:key2, :value2}, {:hoge_key, :hoge_value}] 12 | -------------------------------------------------------------------------------- /Hash/to_s.cr: -------------------------------------------------------------------------------- 1 | hash = { 2 | key1: :value1, 3 | key2: :value2, 4 | hoge_key: :hoge_value 5 | } 6 | 7 | pp hash 8 | puts hash.to_s 9 | 10 | # => hash = {:key1 => :value1, :key2 => :value2, :hoge_key => :hoge_value} 11 | # => {:key1 => :value1, :key2 => :value2, :hoge_key => :hoge_value} 12 | -------------------------------------------------------------------------------- /Hash/values.cr: -------------------------------------------------------------------------------- 1 | hash = { 2 | key1: :value1, 3 | key2: :value2, 4 | hoge_key: :hoge_value 5 | } 6 | 7 | pp hash 8 | puts hash.values 9 | 10 | # => hash = {:key1 => :value1, :key2 => :value2, :hoge_key => :hoge_value} 11 | # => [:value1, :value2, :hoge_value] 12 | -------------------------------------------------------------------------------- /Hash/values_at.cr: -------------------------------------------------------------------------------- 1 | hash = { 2 | key1: :value1, 3 | key2: :value2, 4 | hoge_key: :hoge_value 5 | } 6 | 7 | pp hash 8 | puts hash.values_at(:key1) 9 | puts hash.values_at(:hoge_key) 10 | 11 | # => hash = {:key1 => :value1, :key2 => :value2, :hoge_key => :hoge_value} 12 | # => {:value1} 13 | # => {:hoge_value} 14 | -------------------------------------------------------------------------------- /IniFile/load.cr: -------------------------------------------------------------------------------- 1 | require "inifile" 2 | inifile=<<-EOS 3 | ;人々 4 | [田中] 5 | Name=田中 6 | Age=24 7 | 8 | ;ここから自陣営の情報 9 | [佐藤] 10 | Name=佐藤 11 | Age=35 12 | EOS 13 | puts inifile 14 | puts IniFile.load(inifile) 15 | 16 | # => ;人々 17 | # => [田中] 18 | # => Name=田中 19 | # => Age=24 20 | # => 21 | # => ;ここから自陣営の情報 22 | # => [佐藤] 23 | # => Name=佐藤 24 | # => Age=35 25 | # => {"田中" => {"Name" => "田中", "Age" => "24"}, "佐藤" => {"Name" => "佐藤", "Age" => "35"}} 26 | -------------------------------------------------------------------------------- /Int/abs.cr: -------------------------------------------------------------------------------- 1 | pp 1.abs 2 | pp 0.abs 3 | pp -1.abs 4 | 5 | # => 1.abs = 1 6 | # => 0.abs = 0 7 | # => -1.abs = 1 8 | -------------------------------------------------------------------------------- /Int/amp.cr: -------------------------------------------------------------------------------- 1 | pp 1&1 2 | pp 2&1 3 | pp 4&4 4 | 5 | # => 1 & 1 = 1 6 | # => 2 & 1 = 0 7 | # => 4 & 4 = 4 8 | -------------------------------------------------------------------------------- /Int/bit.cr: -------------------------------------------------------------------------------- 1 | pp 6.bit(0) 2 | pp 6.bit(1) 3 | pp 6.bit(2) 4 | pp 6.bit(3) 5 | 6 | # => 6.bit(0) = 0 7 | # => 6.bit(1) = 1 8 | # => 6.bit(2) = 1 9 | # => 6.bit(3) = 0 10 | -------------------------------------------------------------------------------- /Int/ceil.cr: -------------------------------------------------------------------------------- 1 | pp 8.ceil 2 | pp 8.ceil == 8 3 | 4 | # => 8.ceil = 8 5 | # => 8.ceil == 8 = true 6 | -------------------------------------------------------------------------------- /Int/chr.cr: -------------------------------------------------------------------------------- 1 | pp 90.chr 2 | pp 91.chr 3 | 4 | # => 90.chr = 'Z' 5 | # => 91.chr = '[' 6 | -------------------------------------------------------------------------------- /Int/day.cr: -------------------------------------------------------------------------------- 1 | pp 90.day 2 | pp 91.day 3 | 4 | # => 90.day = 90.00:00:00 5 | # => 91.day = 91.00:00:00 6 | -------------------------------------------------------------------------------- /Int/days.cr: -------------------------------------------------------------------------------- 1 | pp 90.days 2 | pp 91.days 3 | 4 | # => 90.day = 90.00:00:00 5 | # => 91.day = 91.00:00:00 6 | -------------------------------------------------------------------------------- /Int/divide.cr: -------------------------------------------------------------------------------- 1 | pp 1 / 2 2 | pp 2 / 3 3 | pp 2 / 2 4 | pp 3 / 2 5 | pp 4 / 2 6 | 7 | # => 1 / 2 = 0 8 | # => 2 / 3 = 0 9 | # => 2 / 2 = 1 10 | # => 3 / 2 = 1 11 | # => 4 / 2 = 2 12 | -------------------------------------------------------------------------------- /Int/divisible_by.cr: -------------------------------------------------------------------------------- 1 | puts 256.divisible_by?(257) 2 | puts 256.divisible_by?(2) 3 | 4 | # => false 5 | # => true 6 | -------------------------------------------------------------------------------- /Int/down_to.cr: -------------------------------------------------------------------------------- 1 | pp 256.downto(254) 2 | pp 256.downto(250) 3 | 4 | # => 256.downto(254) = # 5 | # => 256.downto(250) = # 6 | -------------------------------------------------------------------------------- /Int/even.cr: -------------------------------------------------------------------------------- 1 | pp 1.even? 2 | pp 2.even? 3 | 4 | # => 1.even? = false 5 | # => 2.even? = true 6 | -------------------------------------------------------------------------------- /Int/gcd.cr: -------------------------------------------------------------------------------- 1 | pp 10.gcd(5) 2 | pp 21.gcd(3) 3 | 4 | # => 10.gcd(5) = 5 5 | # => 21.gcd(3) = 3 6 | -------------------------------------------------------------------------------- /Int/hour.cr: -------------------------------------------------------------------------------- 1 | pp 10.hour 2 | pp 256.hour 3 | 4 | # => 10.hour = 10:00:00 5 | # => 256.hour = 10.16:00:00 6 | -------------------------------------------------------------------------------- /Int/hours.cr: -------------------------------------------------------------------------------- 1 | pp 10.hours 2 | pp 256.hours 3 | 4 | # => 10.hours = 10:00:00 5 | # => 256.hours = 10.16:00:00 6 | -------------------------------------------------------------------------------- /Int/lcm.cr: -------------------------------------------------------------------------------- 1 | pp 12.lcm(13) 2 | pp 12.lcm(18) 3 | pp 12.lcm(24) 4 | 5 | # => 12.lcm(13) = 156 6 | # => 12.lcm(18) = 36 7 | # => 12.lcm(24) = 24 8 | -------------------------------------------------------------------------------- /Int/lshift.cr: -------------------------------------------------------------------------------- 1 | pp 256 << 1 2 | pp 256 << 2 3 | pp 256 << 3 4 | 5 | # => 256 << 1 = 512 6 | # => 256 << 2 = 1024 7 | # => 256 << 3 = 2048 8 | -------------------------------------------------------------------------------- /Int/millisecond.cr: -------------------------------------------------------------------------------- 1 | pp 10.millisecond 2 | pp 100.millisecond 3 | pp 1000.millisecond 4 | 5 | # => 10.millisecond = 00:00:00.0100000 6 | # => 100.millisecond = 00:00:00.1000000 7 | # => 1000.millisecond = 00:00:01 8 | -------------------------------------------------------------------------------- /Int/milliseconds.cr: -------------------------------------------------------------------------------- 1 | pp 10.milliseconds 2 | pp 100.milliseconds 3 | pp 1000.milliseconds 4 | 5 | # => 10.milliseconds = 00:00:00.0100000 6 | # => 100.milliseconds = 00:00:00.1000000 7 | # => 1000.milliseconds = 00:00:01 8 | -------------------------------------------------------------------------------- /Int/minus.cr: -------------------------------------------------------------------------------- 1 | pp 1-1 2 | pp 4-2 3 | pp 4-4 4 | pp 2-4 5 | 6 | # => 1 - 1 = 0 7 | # => 4 - 2 = 2 8 | # => 4 - 4 = 0 9 | # => 2 - 4 = -2 10 | -------------------------------------------------------------------------------- /Int/minute.cr: -------------------------------------------------------------------------------- 1 | pp 10.minute 2 | pp 100.minute 3 | pp 1000.minute 4 | 5 | # => 10.minute = 00:10:00 6 | # => 100.minute = 01:40:00 7 | # => 1000.minute = 16:40:00 8 | -------------------------------------------------------------------------------- /Int/minutes.cr: -------------------------------------------------------------------------------- 1 | pp 10.minutes 2 | pp 100.minutes 3 | pp 1000.minutes 4 | 5 | # => 10.minutes = 00:10:00 6 | # => 100.minutes = 01:40:00 7 | # => 1000.minutes = 16:40:00 8 | -------------------------------------------------------------------------------- /Int/modulo.cr: -------------------------------------------------------------------------------- 1 | pp 3.modulo(4) 2 | pp 3.modulo(3) 3 | pp 3.modulo(2) 4 | pp 3.modulo(1) 5 | 6 | # => 3.modulo(4) = 3 7 | # => 3.modulo(3) = 0 8 | # => 3.modulo(2) = 1 9 | # => 3.modulo(1) = 0 10 | -------------------------------------------------------------------------------- /Int/month.cr: -------------------------------------------------------------------------------- 1 | pp 1.month 2 | pp 3.month 3 | pp 13.month 4 | 5 | # => 1.month = Time::MonthSpan(@value=1) 6 | # => 3.month = Time::MonthSpan(@value=3) 7 | # => 13.month = Time::MonthSpan(@value=13) 8 | -------------------------------------------------------------------------------- /Int/months.cr: -------------------------------------------------------------------------------- 1 | pp 1.months 2 | pp 3.months 3 | pp 13.months 4 | 5 | # => 1.months = Time::MonthSpan(@value=1) 6 | # => 3.months = Time::MonthSpan(@value=3) 7 | # => 13.months = Time::MonthSpan(@value=13) 8 | -------------------------------------------------------------------------------- /Int/multiply.cr: -------------------------------------------------------------------------------- 1 | pp 1*1 2 | pp 2*1 3 | pp 4*4 4 | 5 | # => 1 * 1 = 1 6 | # => 2 * 1 = 2 7 | # => 4 * 4 = 16 8 | -------------------------------------------------------------------------------- /Int/odd.cr: -------------------------------------------------------------------------------- 1 | pp 1.odd? 2 | pp 2.odd? 3 | 4 | # => 1.odd? = true 5 | # => 2.odd? = false 6 | -------------------------------------------------------------------------------- /Int/percent.cr: -------------------------------------------------------------------------------- 1 | pp 1%1 2 | pp 2%1 3 | pp 1%2 4 | 5 | # => 1 % 1 = 0 6 | # => 2 % 1 = 0 7 | # => 1 % 2 = 1 8 | -------------------------------------------------------------------------------- /Int/plus.cr: -------------------------------------------------------------------------------- 1 | pp 1+1 2 | pp 2+1 3 | pp 4+4 4 | 5 | # => 1 + 1 = 2 6 | # => 2 + 1 = 3 7 | # => 4 + 4 = 8 8 | -------------------------------------------------------------------------------- /Int/power.cr: -------------------------------------------------------------------------------- 1 | pp 1**1 2 | pp 2**1 3 | pp 2**2 4 | pp 4**4 5 | 6 | # => 1 ** 1 = 1 7 | # => 2 ** 1 = 2 8 | # => 2 ** 2 = 4 9 | # => 4 ** 4 = 256 10 | -------------------------------------------------------------------------------- /Int/pred.cr: -------------------------------------------------------------------------------- 1 | pp 1.pred 2 | pp 10.pred 3 | 4 | # => 1.pred = 0 5 | # => 10.pred = 9 6 | -------------------------------------------------------------------------------- /Int/rshift.cr: -------------------------------------------------------------------------------- 1 | pp 256 >> 1 2 | pp 256 >> 2 3 | pp 256 >> 3 4 | 5 | # => 256 >> 1 = 128 6 | # => 256 >> 2 = 64 7 | # => 256 >> 3 = 32 8 | -------------------------------------------------------------------------------- /Int/second.cr: -------------------------------------------------------------------------------- 1 | pp 10.second 2 | pp 100.second 3 | pp 1000.second 4 | 5 | # => 10.second = 00:00:10 6 | # => 100.second = 00:01:40 7 | # => 1000.second = 00:16:40 8 | -------------------------------------------------------------------------------- /Int/seconds.cr: -------------------------------------------------------------------------------- 1 | pp 10.seconds 2 | pp 100.seconds 3 | pp 1000.seconds 4 | 5 | # => 10.seconds = 00:00:10 6 | # => 100.seconds = 00:01:40 7 | # => 1000.seconds = 00:16:40 8 | -------------------------------------------------------------------------------- /Int/succ.cr: -------------------------------------------------------------------------------- 1 | pp 1.succ 2 | pp 2.succ 3 | 4 | # => 1.succ = 2 5 | # => 2.succ = 3 6 | -------------------------------------------------------------------------------- /Int/times.cr: -------------------------------------------------------------------------------- 1 | 3.times{|e|pp "#{e}times"} 2 | 3 | # => "#{e}times" = "0times" 4 | # => "#{e}times" = "1times" 5 | # => "#{e}times" = "2times" 6 | -------------------------------------------------------------------------------- /Int/to.cr: -------------------------------------------------------------------------------- 1 | 3.to(5){|e|pp "#{e}times"} 2 | 2.to(7){|e|pp "#{e}times"} 3 | 4 | # => "#{e}times" = "3times" 5 | # => "#{e}times" = "4times" 6 | # => "#{e}times" = "5times" 7 | # => "#{e}times" = "2times" 8 | # => "#{e}times" = "3times" 9 | # => "#{e}times" = "4times" 10 | # => "#{e}times" = "5times" 11 | # => "#{e}times" = "6times" 12 | # => "#{e}times" = "7times" 13 | -------------------------------------------------------------------------------- /Int/upto.cr: -------------------------------------------------------------------------------- 1 | 3.upto(5){|e|pp "#{e}times"} 2 | 3.upto(1){|e|pp "#{e}times"} 3 | 4 | # => "#{e}times" = "3times" 5 | # => "#{e}times" = "4times" 6 | # => "#{e}times" = "5times" 7 | -------------------------------------------------------------------------------- /Int/week.cr: -------------------------------------------------------------------------------- 1 | pp 2.week 2 | pp 3.week 3 | 4 | # => 2.week = 14.00:00:00 5 | # => 3.week = 21.00:00:00 6 | -------------------------------------------------------------------------------- /Int/weeks.cr: -------------------------------------------------------------------------------- 1 | pp 2.weeks 2 | pp 3.weeks 3 | 4 | # => 2.weeks = 14.00:00:00 5 | # => 3.weeks = 21.00:00:00 6 | -------------------------------------------------------------------------------- /Int/year.cr: -------------------------------------------------------------------------------- 1 | pp 2.year 2 | pp 3.year 3 | 4 | # => 2.year = Time::MonthSpan(@value=24) 5 | # => 3.year = Time::MonthSpan(@value=36) 6 | -------------------------------------------------------------------------------- /Int/years.cr: -------------------------------------------------------------------------------- 1 | pp 2.years 2 | pp 3.years 3 | 4 | # => 2.years = Time::MonthSpan(@value=24) 5 | # => 3.years = Time::MonthSpan(@value=36) 6 | -------------------------------------------------------------------------------- /Markdown/to_html.cr: -------------------------------------------------------------------------------- 1 | require "markdown" 2 | 3 | text = <<-EOS 4 | # h1 5 | ## h2 6 | * list1 7 | * list2 8 | * list3 9 | 10 | 1. number list1 11 | 1. number list2 12 | 1. number list3 13 | 14 | *strong - em tag* 15 | **strong - strong tag** 16 | EOS 17 | 18 | pp Markdown.to_html(text) 19 | 20 | # => Markdown.to_html(text) = "

h1

\n\n

h2

\n\n
  • list1
  • list2
  • list3
\n\n
  1. number list1
  2. number list2
  3. number list3
\n\n

strong - em tag\nstrong - strong tag

" 21 | -------------------------------------------------------------------------------- /Nil/eqeq.cr: -------------------------------------------------------------------------------- 1 | pp nil == nil 2 | pp nil == false 3 | 4 | # => nil == nil = true 5 | # => nil == false = false 6 | -------------------------------------------------------------------------------- /Nil/hash.cr: -------------------------------------------------------------------------------- 1 | pp nil.hash 2 | 3 | # => nil.hash = 0 4 | -------------------------------------------------------------------------------- /Nil/inspect.cr: -------------------------------------------------------------------------------- 1 | pp nil.inspect 2 | 3 | # => nil.inspect = "nil" 4 | -------------------------------------------------------------------------------- /Nil/nil_q.cr: -------------------------------------------------------------------------------- 1 | pp nil.nil? 2 | pp false.nil? 3 | 4 | # => nil.nil? = true 5 | # => false.nil? = false 6 | -------------------------------------------------------------------------------- /Nil/not.cr: -------------------------------------------------------------------------------- 1 | pp nil 2 | pp !nil 3 | 4 | # => nil = nil 5 | # => !nil = true 6 | -------------------------------------------------------------------------------- /Nil/object_id.cr: -------------------------------------------------------------------------------- 1 | pp nil.object_id 2 | 3 | # => nil.object_id = 0 -------------------------------------------------------------------------------- /Nil/same.cr: -------------------------------------------------------------------------------- 1 | pp nil.same?(nil) 2 | pp nil.same?("test") 3 | 4 | # => nil.same?(nil) = true 5 | # => nil.same?("test") = false 6 | -------------------------------------------------------------------------------- /Nil/to_s.cr: -------------------------------------------------------------------------------- 1 | pp nil.to_s 2 | 3 | # => nil.to_s = "" -------------------------------------------------------------------------------- /Nil/try.cr: -------------------------------------------------------------------------------- 1 | nil.try { 2 | pp "hoge" 3 | } 4 | 5 | # Doesn't yields to the block. -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Crystal Samples 2 | 3 | -------------------------------------------------------------------------------- /Range/begin.cr: -------------------------------------------------------------------------------- 1 | pp Range.new(1, 3).begin 2 | pp Range.new(2, 3).begin 3 | 4 | # => (Range.new(1, 3)).begin = 1 5 | # => (Range.new(2, 3)).begin = 2 6 | -------------------------------------------------------------------------------- /Range/covers.cr: -------------------------------------------------------------------------------- 1 | pp Range.new(1, 10).covers?(1) 2 | pp Range.new(1, 10).covers?(10) 3 | pp Range.new(1, 10).covers?(11) 4 | 5 | # => (Range.new(1, 10)).covers?(1) = true 6 | # => (Range.new(1, 10)).covers?(10) = true 7 | # => (Range.new(1, 10)).covers?(11) = false 8 | -------------------------------------------------------------------------------- /Range/cycle.cr: -------------------------------------------------------------------------------- 1 | pp Range.new(1, 3).cycle 2 | pp Range.new(1, 3).cycle.first(8).to_a 3 | 4 | # => (Range.new(1, 3)).cycle = Iterator::Cycle(Range::ItemIterator(Int32, Int32), Int32)(@iterator=#) 5 | # => ((Range.new(1, 3)).cycle.first(8)).to_a = [1, 2, 3, 1, 2, 3, 1, 2] 6 | -------------------------------------------------------------------------------- /Range/each.cr: -------------------------------------------------------------------------------- 1 | Range.new(1, 5).each{|e|pp e} 2 | 3 | # => e = 1 4 | # => e = 2 5 | # => e = 3 6 | # => e = 4 7 | # => e = 5 8 | -------------------------------------------------------------------------------- /Range/end.cr: -------------------------------------------------------------------------------- 1 | pp Range.new(1, 3).end 2 | pp Range.new(1, 5).end 3 | 4 | # => (Range.new(1, 3)).end = 3 5 | # => (Range.new(1, 5)).end = 5 6 | -------------------------------------------------------------------------------- /Range/eqeqeq.cr: -------------------------------------------------------------------------------- 1 | pp Range.new(1, 3) === 1 2 | pp Range.new(1, 3) === 3 3 | pp Range.new(1, 3) === 4 4 | pp Range.new(1, 3, true) === 2 5 | pp Range.new(1, 3, true) === 3 6 | 7 | # => (Range.new(1, 3)) === 1 = true 8 | # => (Range.new(1, 3)) === 3 = true 9 | # => (Range.new(1, 3)) === 4 = false 10 | # => (Range.new(1, 3, true)) === 2 = true 11 | # => (Range.new(1, 3, true)) === 3 = false 12 | -------------------------------------------------------------------------------- /Range/excludes_end.cr: -------------------------------------------------------------------------------- 1 | pp Range.new(1, 3).excludes_end? 2 | pp Range.new(1, 3, false).excludes_end? 3 | pp Range.new(1, 3, true).excludes_end? 4 | 5 | # => (Range.new(1, 3)).excludes_end? = false 6 | # => (Range.new(1, 3, false)).excludes_end? = false 7 | # => (Range.new(1, 3, true)).excludes_end? = true 8 | -------------------------------------------------------------------------------- /Range/exclusive.cr: -------------------------------------------------------------------------------- 1 | pp Range.new(1, 3).exclusive? 2 | pp Range.new(1, 3, false).exclusive? 3 | pp Range.new(1, 3, true).exclusive? 4 | 5 | # => (Range.new(1, 3)).exclusive? = false 6 | # => (Range.new(1, 3, false)).exclusive? = false 7 | # => (Range.new(1, 3, true)).exclusive? = true 8 | -------------------------------------------------------------------------------- /Range/includes.cr: -------------------------------------------------------------------------------- 1 | pp Range.new(1, 3).includes?(0) 2 | pp Range.new(1, 3).includes?(1) 3 | pp Range.new(1, 3).includes?(3) 4 | pp Range.new(1, 3).includes?(4) 5 | 6 | # => (Range.new(1, 3)).includes?(0) = false 7 | # => (Range.new(1, 3)).includes?(1) = true 8 | # => (Range.new(1, 3)).includes?(3) = true 9 | # => (Range.new(1, 3)).includes?(4) = false 10 | -------------------------------------------------------------------------------- /Range/new.cr: -------------------------------------------------------------------------------- 1 | pp Range.new(1, 3) 2 | pp Range.new(1, 3, false) 3 | pp Range.new(1, 3, true) 4 | 5 | # => Range.new(1, 3) = 1..3 6 | # => Range.new(1, 3, false) = 1..3 7 | # => Range.new(1, 3, true) = 1...3 8 | -------------------------------------------------------------------------------- /Range/reverse_each.cr: -------------------------------------------------------------------------------- 1 | Range.new(1, 5).reverse_each{|e|pp e} 2 | 3 | # => e = 5 4 | # => e = 4 5 | # => e = 3 6 | # => e = 2 7 | # => e = 1 8 | -------------------------------------------------------------------------------- /Range/step.cr: -------------------------------------------------------------------------------- 1 | Range.new(1, 10).step(2){|e|pp e} 2 | Range.new(1, 10).step(3){|e|pp e} 3 | 4 | # => e = 1 5 | # => e = 3 6 | # => e = 5 7 | # => e = 7 8 | # => e = 9 9 | # => e = 1 10 | # => e = 4 11 | # => e = 7 12 | # => e = 10 13 | -------------------------------------------------------------------------------- /Range/sum.cr: -------------------------------------------------------------------------------- 1 | pp Range.new(1, 10).sum(3) 2 | pp Range.new("a", "z").sum("0") 3 | 4 | # => (Range.new(1, 10)).sum(3) = 58 5 | # => (Range.new("a", "z")).sum("0") = "0abcdefghijklmnopqrstuvwxyz" 6 | -------------------------------------------------------------------------------- /Regex/eq.cr: -------------------------------------------------------------------------------- 1 | pp /(hoge|hage)/ == /(hoge|hage)/ 2 | pp /(hoge|hage)/ == /(hoge|hege)/ 3 | 4 | # (/(hoge|hage)/) == (/(hoge|hage)/) = true 5 | # (/(hoge|hage)/) == (/(hoge|hege)/) = false 6 | -------------------------------------------------------------------------------- /Regex/eq_tilde.cr: -------------------------------------------------------------------------------- 1 | pp /h.ge/ =~ "hogehigehage" 2 | pp $~ 3 | pp /h.ge/ =~ "not exist" 4 | 5 | # (/h.ge/) =~ "hogehigehage" = 0 6 | # $~.not_nil! = # 7 | # (/h.ge/) =~ "not exist" = nil 8 | -------------------------------------------------------------------------------- /Regex/error.cr: -------------------------------------------------------------------------------- 1 | pp Regex.error?("(hoge|hige)") 2 | pp Regex.error?("(hoge|hige") 3 | 4 | # => Regex.error?("(hoge|hige)") = nil 5 | # => Regex.error?("(hoge|hige") = "missing ) at 10" 6 | -------------------------------------------------------------------------------- /Regex/escape.cr: -------------------------------------------------------------------------------- 1 | pp Regex.escape("/.+") 2 | pp Regex.escape("normal") 3 | 4 | # => Regex.escape("/.+") = "/\\.\\+" 5 | # => Regex.escape("normal") = "normal" 6 | -------------------------------------------------------------------------------- /Regex/inspect.cr: -------------------------------------------------------------------------------- 1 | pp /h.ge/.inspect 2 | pp /(hoge|hige|hage)/.inspect 3 | 4 | # (/h.ge/).inspect = "/h.ge/" 5 | # (/(hoge|hige|hage)/).inspect = "/(hoge|hige|hage)/" 6 | -------------------------------------------------------------------------------- /Regex/match.cr: -------------------------------------------------------------------------------- 1 | pp /h.ge/.match("hogehgiehage") 2 | pp /h.ge/.match("bar") 3 | 4 | # (/h.ge/).match("hogehgiehage") = # 5 | # (/h.ge/).match("bar") = nil 6 | -------------------------------------------------------------------------------- /Regex/name_table.cr: -------------------------------------------------------------------------------- 1 | pp /(hoge)/.name_table 2 | pp /(?.+)/.name_table 3 | pp /(?.+) (?\d{1, 3})/.name_table 4 | 5 | # => (/(hoge)/).name_table = {} 6 | # => (/(?.+)/).name_table = {1 => "name"} 7 | # => (/(?.+) (?\d{1, 3})/).name_table = {2 => "age", 1 => "name"} 8 | -------------------------------------------------------------------------------- /Regex/options.cr: -------------------------------------------------------------------------------- 1 | puts /hoge/.options 2 | puts /hoge/i.options 3 | puts /hoge/ix.options 4 | 5 | # => None 6 | # => IGNORE_CASE 7 | # => IGNORE_CASE, EXTENDED 8 | -------------------------------------------------------------------------------- /Regex/plus.cr: -------------------------------------------------------------------------------- 1 | regex = Regex.new("h.ge") 2 | regex = regex + /ha.e/ 3 | %w(hoge hige hage hane hase hise).map{|e|pp regex.match(e)} 4 | 5 | # => regex.match(e) = # 6 | # => regex.match(e) = # 7 | # => regex.match(e) = # 8 | # => regex.match(e) = # 9 | # => regex.match(e) = # 10 | # => regex.match(e) = nil -------------------------------------------------------------------------------- /Regex/source.cr: -------------------------------------------------------------------------------- 1 | pp /h.ge/.source 2 | pp /h.ge/i.source 3 | 4 | # => (/h.ge/).source = "h.ge" 5 | # => (/h.ge/i).source = "h.ge" 6 | -------------------------------------------------------------------------------- /Regex/to_s.cr: -------------------------------------------------------------------------------- 1 | pp /h.ge/.to_s 2 | pp /h.ge/i.to_s 3 | 4 | # (/h.ge/).to_s = "(?-imsx:h.ge)" 5 | # (/h.ge/i).to_s = "(?i-msx:h.ge)" 6 | -------------------------------------------------------------------------------- /Regex/union.cr: -------------------------------------------------------------------------------- 1 | regex = Regex.union(/h.ge/, /ha.e/) 2 | %w(hoge hige hage hane hase hise).map{|e|pp regex.match(e)} 3 | 4 | # => regex.match(e) = # 5 | # => regex.match(e) = # 6 | # => regex.match(e) = # 7 | # => regex.match(e) = # 8 | # => regex.match(e) = # 9 | # => regex.match(e) = nil 10 | -------------------------------------------------------------------------------- /SecureRandom/base64.cr: -------------------------------------------------------------------------------- 1 | require "secure_random" 2 | 3 | pp SecureRandom.base64(8) 4 | pp SecureRandom.base64(8) 5 | 6 | # SecureRandom.base64(8) = "x+kS0RGFXFc=" 7 | # SecureRandom.base64(8) = "rLDyeTjPpCI=" 8 | -------------------------------------------------------------------------------- /SecureRandom/hex.cr: -------------------------------------------------------------------------------- 1 | require "secure_random" 2 | 3 | pp SecureRandom.hex 4 | pp SecureRandom.hex(2) 5 | 6 | # ecureRandom.hex = "3cf6483b89da26125110ca7c46bc0b71" 7 | # SecureRandom.hex(2) = "b4be" 8 | -------------------------------------------------------------------------------- /SecureRandom/random_bytes.cr: -------------------------------------------------------------------------------- 1 | require "secure_random" 2 | 3 | pp SecureRandom.random_bytes 4 | pp SecureRandom.random_bytes(8) 5 | 6 | # SecureRandom.random_bytes = Slice[26, 150, 60, 6, 8, 78, 28, 133, 35, 28, 187, 159, 75, 7, 152, 172] 7 | # SecureRandom.random_bytes(8) = Slice[59, 175, 36, 176, 198, 209, 74, 177] 8 | -------------------------------------------------------------------------------- /SecureRandom/urlsafe_base64.cr: -------------------------------------------------------------------------------- 1 | require "secure_random" 2 | 3 | pp SecureRandom.urlsafe_base64 4 | pp SecureRandom.urlsafe_base64(8) 5 | pp SecureRandom.urlsafe_base64(8) 6 | 7 | # SecureRandom.urlsafe_base64 = "c4mKXv_AyUrmvG2IRFqCcw" 8 | # SecureRandom.urlsafe_base64(8) = "88ySvAqW8gw" 9 | # SecureRandom.urlsafe_base64(8) = "O3AszQtir_Y" 10 | -------------------------------------------------------------------------------- /SecureRandom/uuid.cr: -------------------------------------------------------------------------------- 1 | require "secure_random" 2 | 3 | pp SecureRandom.uuid 4 | pp SecureRandom.uuid 5 | 6 | # SecureRandom.uuid = "038fda63-7c60-4a7a-9fc1-26fd7765c5ab" 7 | # SecureRandom.uuid = "1bdb890d-22b7-404f-beee-e29df3de2b8a" 8 | -------------------------------------------------------------------------------- /Set/add.cr: -------------------------------------------------------------------------------- 1 | pp Set.new(%w(a b c)).add("d") 2 | pp Set.new(%w(a b c)).add("d").add("e") 3 | 4 | # (Set.new(["a", "b", "c"] of ::String)).add("d") # => Set{"a", "b", "c", "d"} 5 | # ((Set.new(["a", "b", "c"] of ::String)).add("d")).add("e") # => Set{"a", "b", "c", "d", "e"} 6 | -------------------------------------------------------------------------------- /Set/and.cr: -------------------------------------------------------------------------------- 1 | pp Set.new(%w(hoge hige hage)) & Set.new(%w(hoge hege hage)) 2 | pp Set.new(%w(a c d e)) & Set.new(%w(b d g z)) 3 | 4 | # (Set.new(["hoge", "hige", "hage"] of ::String)) & (Set.new(["hoge", "hege", "hage"] of ::String)) = Set{"hoge", "hage"} 5 | # (Set.new(["a", "c", "d", "e"] of ::String)) & (Set.new(["b", "d", "g", "z"] of ::String)) = Set{"d"} 6 | -------------------------------------------------------------------------------- /Set/clear.cr: -------------------------------------------------------------------------------- 1 | pp Set.new(%w(a b c)).clear 2 | 3 | # (Set.new(["a", "b", "c"] of ::String)).clear # => Set{} 4 | -------------------------------------------------------------------------------- /Set/clone.cr: -------------------------------------------------------------------------------- 1 | a = Set.new(%w(a b c)) 2 | b = a.clone 3 | pp a 4 | pp b 5 | pp a == b 6 | 7 | # a # => Set{"a", "b", "c"} 8 | # b # => Set{"a", "b", "c"} 9 | # a == b # => true 10 | 11 | -------------------------------------------------------------------------------- /Set/delete.cr: -------------------------------------------------------------------------------- 1 | s = Set.new(%w(a b c)) 2 | pp s 3 | pp s.delete("a") 4 | pp s.delete("b") 5 | pp s.delete("d") 6 | 7 | # s = Set{"a", "b", "c"} 8 | # s.delete("a") = Set{"b", "c"} 9 | # s.delete("b") = Set{"c"} 10 | # s.delete("d") = Set{"c"} 11 | -------------------------------------------------------------------------------- /Set/each.cr: -------------------------------------------------------------------------------- 1 | s = Set.new(%w(a b c)) 2 | s.each { |e| puts e } 3 | 4 | # s = Set{"a", "b", "c"} 5 | # s.delete("a") = Set{"b", "c"} 6 | # s.delete("b") = Set{"c"} 7 | # s.delete("d") = Set{"c"} 8 | -------------------------------------------------------------------------------- /Set/empty.cr: -------------------------------------------------------------------------------- 1 | pp Set.new(%w(hoge hige hage)).empty? 2 | pp Set(String).new().empty? 3 | 4 | # (Set.new(["hoge", "hige", "hage"] of ::String)).empty? = false 5 | # Set(String).new.empty? = true 6 | -------------------------------------------------------------------------------- /Set/eqeq.cr: -------------------------------------------------------------------------------- 1 | pp Set.new(%w(hoge hige hage)) == Set.new(%w(hoge hege hage)) 2 | pp Set.new(%w(hoge hige hage)) == Set.new(%w(hoge hige hage)) 3 | 4 | # (Set.new(["hoge", "hige", "hage"] of ::String)) == (Set.new(["hoge", "hege", "hage"] of ::String)) = false 5 | # (Set.new(["hoge", "hige", "hage"] of ::String)) == (Set.new(["hoge", "hige", "hage"] of ::String)) = true 6 | -------------------------------------------------------------------------------- /Set/includes.cr: -------------------------------------------------------------------------------- 1 | s = Set.new(%w(hoge hige hage)) 2 | pp s 3 | pp s.includes?("hoge") 4 | pp s.includes?("hige") 5 | pp s.includes?("hege") 6 | 7 | # s = Set{"hoge", "hige", "hage"} 8 | # s.includes?("hoge") = true 9 | # s.includes?("hige") = true 10 | # s.includes?("hege") = false 11 | -------------------------------------------------------------------------------- /Set/intersects.cr: -------------------------------------------------------------------------------- 1 | pp Set(Int32).new([1, 2, 3]).intersects?(Set(Int32).new([1, 5])) 2 | pp Set(Int32).new([1, 2, 3]).intersects?(Set(Int32).new([4, 5])) 3 | 4 | # => (Set(Int32).new([1, 2, 3])).intersects?(Set(Int32).new([1, 5])) # => true 5 | # => (Set(Int32).new([1, 2, 3])).intersects?(Set(Int32).new([4, 5])) # => false 6 | -------------------------------------------------------------------------------- /Set/merge.cr: -------------------------------------------------------------------------------- 1 | pp Set(Int32).new([1, 2, 3]).merge(Set(Int32).new([1, 5])) 2 | pp Set(Int32).new([1, 2, 3]).merge(Set(Int32).new([4, 5])) 3 | 4 | # => (Set(Int32).new([1, 2, 3])).merge(Set(Int32).new([1, 5])) # => Set{1, 2, 3, 5} 5 | # => (Set(Int32).new([1, 2, 3])).merge(Set(Int32).new([4, 5])) # => Set{1, 2, 3, 4, 5} 6 | -------------------------------------------------------------------------------- /Set/minus.cr: -------------------------------------------------------------------------------- 1 | pp Set(Int32).new([1, 2, 3]) - Set(Int32).new([1, 3]) 2 | pp Set(Int32).new([1, 2, 3]) - Set(Int32).new([4, 5]) 3 | 4 | # => (Set(Int32).new([1, 2, 3])) - (Set(Int32).new([1, 3])) = Set{2} 5 | # => (Set(Int32).new([1, 2, 3])) - (Set(Int32).new([4, 5])) = Set{1, 2, 3} 6 | -------------------------------------------------------------------------------- /Set/new.cr: -------------------------------------------------------------------------------- 1 | pp Set(Int32).new 2 | 3 | # Set(Int32).new = Set{} 4 | -------------------------------------------------------------------------------- /Set/proper_subset.cr: -------------------------------------------------------------------------------- 1 | pp Set(Int32).new([1, 3]).proper_subset?(Set(Int32).new([1, 3, 5])) 2 | pp Set(Int32).new([1, 3, 5]).proper_subset?(Set(Int32).new([1, 3, 5])) 3 | 4 | # => (Set(Int32).new([1, 3])).proper_subset?(Set(Int32).new([1, 3, 5])) # => true 5 | # => (Set(Int32).new([1, 3, 5])).proper_subset?(Set(Int32).new([1, 3, 5])) # => false 6 | -------------------------------------------------------------------------------- /Set/proper_superset.cr: -------------------------------------------------------------------------------- 1 | pp Set(Char).new(['a', 'b', 'c']).proper_superset?(Set(Char).new(['a', 'c'])) 2 | pp Set(Char).new(['a', 'b', 'c']).proper_superset?(Set(Char).new(['a', 'b', 'c'])) 3 | 4 | # (Set(Char).new(['a', 'b', 'c'])).proper_superset?(Set(Char).new(['a', 'c'])) = true 5 | # (Set(Char).new(['a', 'b', 'c'])).proper_superset?(Set(Char).new(['a', 'b', 'c'])) = false 6 | -------------------------------------------------------------------------------- /Set/sdiff.cr: -------------------------------------------------------------------------------- 1 | pp Set.new(%w(a b c)) ^ Set.new(%w(a b c)) 2 | pp Set.new(%w(a b c)) ^ Set.new(%w(b c d)) 3 | 4 | # (Set.new(["a", "b", "c"] of ::String)) ^ (Set.new(["a", "b", "c"] of ::String)) = Set{} 5 | # (Set.new(["a", "b", "c"] of ::String)) ^ (Set.new(["b", "c", "d"] of ::String)) = Set{"a", "d"} 6 | -------------------------------------------------------------------------------- /Set/size.cr: -------------------------------------------------------------------------------- 1 | pp Set(Char).new(['a', 'b', 'c']).size 2 | pp Set(Char).new(['a']).size 3 | 4 | # (Set(Char).new(['a', 'b', 'c'])).size = 3 5 | # (Set(Char).new(['a'])).size = 1 6 | -------------------------------------------------------------------------------- /Set/subset.cr: -------------------------------------------------------------------------------- 1 | pp Set(Char).new(['a', 'b']).subset?(Set(Char).new(['a', 'b', 'c'])) 2 | pp Set(Char).new(['a', 'b', 'c']).subset?(Set(Char).new(['a', 'b', 'c'])) 3 | pp Set(Char).new(['a', 'b', 'd']).subset?(Set(Char).new(['a', 'b', 'c'])) 4 | 5 | # (Set(Char).new(['a', 'b'])).subset?(Set(Char).new(['a', 'b', 'c'])) = true 6 | # (Set(Char).new(['a', 'b', 'c'])).subset?(Set(Char).new(['a', 'b', 'c'])) = true 7 | # (Set(Char).new(['a', 'b', 'd'])).subset?(Set(Char).new(['a', 'b', 'c'])) = false 8 | -------------------------------------------------------------------------------- /Set/subtract.cr: -------------------------------------------------------------------------------- 1 | pp Set(Char).new(['a', 'b', 'c']).subtract(Set(Char).new(['a', 'b', 'c'])) 2 | pp Set(Char).new(['a', 'b', 'd']).subtract(Set(Char).new(['a', 'b', 'c'])) 3 | 4 | # (Set(Char).new(['a', 'b', 'c'])).subtract(Set(Char).new(['a', 'b', 'c'])) # => Set{} 5 | # (Set(Char).new(['a', 'b', 'd'])).subtract(Set(Char).new(['a', 'b', 'c'])) # => Set{'d'} 6 | -------------------------------------------------------------------------------- /Set/superset.cr: -------------------------------------------------------------------------------- 1 | pp Set(Char).new(['a', 'b']).subset?(Set(Char).new(['a', 'b', 'c'])) 2 | pp Set(Char).new(['a', 'b', 'c']).subset?(Set(Char).new(['a', 'b', 'c'])) 3 | pp Set(Char).new(['a', 'b', 'd']).subset?(Set(Char).new(['a', 'b', 'c'])) 4 | 5 | # (Set(Char).new(['a', 'b'])).subset?(Set(Char).new(['a', 'b', 'c'])) = true 6 | # (Set(Char).new(['a', 'b', 'c'])).subset?(Set(Char).new(['a', 'b', 'c'])) = true 7 | # (Set(Char).new(['a', 'b', 'd'])).subset?(Set(Char).new(['a', 'b', 'c'])) = false 8 | -------------------------------------------------------------------------------- /Set/to_a.cr: -------------------------------------------------------------------------------- 1 | print Set(Char).new(['a', 'b']).to_a 2 | 3 | # ['a', 'b'] 4 | -------------------------------------------------------------------------------- /Set/union.cr: -------------------------------------------------------------------------------- 1 | pp Set(Char).new(['a', 'b']) | (Set(Char).new(['a', 'b', 'c'])) 2 | pp Set(Char).new(['a', 'b', 'c']) | (Set(Char).new(['a', 'b', 'c'])) 3 | pp Set(Char).new(['a', 'b', 'd']) | (Set(Char).new(['a', 'b', 'c'])) 4 | 5 | # (Set(Char).new(['a', 'b'])) | (Set(Char).new(['a', 'b', 'c'])) # => Set{'a', 'b', 'c'} 6 | # (Set(Char).new(['a', 'b', 'c'])) | (Set(Char).new(['a', 'b', 'c'])) # => Set{'a', 'b', 'c'} 7 | # (Set(Char).new(['a', 'b', 'd'])) | (Set(Char).new(['a', 'b', 'c'])) # => Set{'a', 'b', 'd', 'c'} 8 | -------------------------------------------------------------------------------- /SimpleHash/bracket.cr: -------------------------------------------------------------------------------- 1 | require "simple_hash" 2 | s = SimpleHash(Symbol, String).new 3 | pp s 4 | s[:key1] = "value1" 5 | pp s 6 | pp s[:key1] 7 | 8 | # s # => {} 9 | # s # => {:key1 => "value1"} 10 | # s[:key1] # => "value1" 11 | -------------------------------------------------------------------------------- /SimpleHash/delete.cr: -------------------------------------------------------------------------------- 1 | require "simple_hash" 2 | s = SimpleHash(Symbol, String).new 3 | pp s 4 | s[:key1] = "value1" 5 | pp s 6 | s.delete(:key1) 7 | pp s 8 | 9 | # s # => {} 10 | # s # => {:key1 => "value1"} 11 | # s # => {} 12 | -------------------------------------------------------------------------------- /SimpleHash/dup.cr: -------------------------------------------------------------------------------- 1 | require "simple_hash" 2 | s = SimpleHash(Symbol, String).new 3 | s[:key1] = "value1" 4 | c = s.dup 5 | pp c 6 | pp c == s 7 | 8 | # c # => {:key1 => "value1"} 9 | # c == s # => true 10 | -------------------------------------------------------------------------------- /SimpleHash/each.cr: -------------------------------------------------------------------------------- 1 | require "simple_hash" 2 | s = SimpleHash(Symbol, String).new 3 | s[:key1] = "value1" 4 | s[:key2] = "value2" 5 | s.each{|k,v|pp "#{k}:#{v}"} 6 | 7 | # "#{k}:#{v}" # => "key1:value1" 8 | # "#{k}:#{v}" # => "key2:value2" 9 | -------------------------------------------------------------------------------- /SimpleHash/each_key.cr: -------------------------------------------------------------------------------- 1 | require "simple_hash" 2 | s = SimpleHash(Symbol, String).new 3 | s[:key1] = "value1" 4 | s[:key2] = "value2" 5 | s.each_key{|e|pp e} 6 | 7 | # e # => :key1 8 | # e # => :key2 9 | -------------------------------------------------------------------------------- /SimpleHash/each_value.cr: -------------------------------------------------------------------------------- 1 | require "simple_hash" 2 | s = SimpleHash(Symbol, String).new 3 | s[:key1] = "value1" 4 | s[:key2] = "value2" 5 | s.each_value{|e|pp e} 6 | 7 | # e # => "value1" 8 | # e # => "value2" 9 | -------------------------------------------------------------------------------- /SimpleHash/each_with_object.cr: -------------------------------------------------------------------------------- 1 | require "simple_hash" 2 | s = SimpleHash(Symbol, String).new 3 | s[:key1] = "value1" 4 | s[:key2] = "value2" 5 | pp s.each_with_object([] of String){|memo, key, value|memo << value.upcase} 6 | 7 | # s.each_with_object([] of String) do |memo, key, value| 8 | # memo << value.upcase 9 | # end # => ["VALUE1", "VALUE2"] 10 | -------------------------------------------------------------------------------- /SimpleHash/fetch.cr: -------------------------------------------------------------------------------- 1 | require "simple_hash" 2 | s = SimpleHash(Symbol, String).new 3 | s[:key1] = "value1" 4 | s[:key2] = "value2" 5 | pp s.fetch(:key1){|value|pp value} 6 | pp s.fetch(:invalid){|value|pp value} 7 | 8 | # s.fetch(:key1) do |value| 9 | # pp(value) 10 | # end # => "value1" 11 | # value # => :invalid 12 | # s.fetch(:invalid) do |value| 13 | # pp(value) 14 | # end # => nil 15 | -------------------------------------------------------------------------------- /SimpleHash/has_key.cr: -------------------------------------------------------------------------------- 1 | require "simple_hash" 2 | s = SimpleHash(Symbol, String).new 3 | s[:key1] = "value1" 4 | s[:key2] = "value2" 5 | pp s.has_key?(:key1) 6 | pp s.has_key?(:key3) 7 | 8 | # s.has_key?(:key1) # => true 9 | # s.has_key?(:key3) # => false 10 | -------------------------------------------------------------------------------- /SimpleHash/keys.cr: -------------------------------------------------------------------------------- 1 | require "simple_hash" 2 | s = SimpleHash(Symbol, String).new 3 | s[:key1] = "value1" 4 | s[:key2] = "value2" 5 | pp s.keys 6 | 7 | # s.keys # => [:key1, :key2] 8 | -------------------------------------------------------------------------------- /SimpleHash/new.cr: -------------------------------------------------------------------------------- 1 | require "simple_hash" 2 | s = SimpleHash(Symbol, String).new 3 | pp s 4 | s[:key1] = "value1" 5 | pp s 6 | s[:key2] = "value2" 7 | pp s 8 | 9 | # s # => {} 10 | # s # => {:key1 => "value1"} 11 | # s # => {:key1 => "value1", :key2 => "value2"} 12 | -------------------------------------------------------------------------------- /SimpleHash/reject.cr: -------------------------------------------------------------------------------- 1 | require "simple_hash" 2 | s = SimpleHash(Symbol, Int32).new 3 | s[:key1] = 1 4 | s[:key2] = 2 5 | s[:key3] = 3 6 | pp s.reject{|key, value|value.odd?} 7 | pp s.reject{|key, value|value.even?} 8 | 9 | # s.reject do |key, value| 10 | # value.odd? 11 | # end # => {:key2 => 2} 12 | # s.reject do |key, value| 13 | # value.even? 14 | # end # => {:key1 => 1, :key3 => 3} 15 | -------------------------------------------------------------------------------- /SimpleHash/select.cr: -------------------------------------------------------------------------------- 1 | require "simple_hash" 2 | s = SimpleHash(Symbol, Int32).new 3 | s[:key1] = 1 4 | s[:key2] = 2 5 | s[:key3] = 3 6 | pp s.select{|key, value|value.odd?} 7 | pp s.select{|key, value|value.even?} 8 | 9 | # s.select do |key, value| 10 | # value.odd? 11 | # end # => {:key1 => 1, :key3 => 3} 12 | # s.select do |key, value| 13 | # value.even? 14 | # end # => {:key2 => 2} 15 | -------------------------------------------------------------------------------- /SimpleHash/size.cr: -------------------------------------------------------------------------------- 1 | require "simple_hash" 2 | s = SimpleHash(Symbol, Int32).new 3 | s[:key1] = 1 4 | s[:key2] = 2 5 | s[:key3] = 3 6 | pp s.size 7 | s[:key4] = 4 8 | pp s.size 9 | 10 | # s.size # => 3 11 | # s.size # => 4 12 | -------------------------------------------------------------------------------- /SimpleHash/values.cr: -------------------------------------------------------------------------------- 1 | require "simple_hash" 2 | s = SimpleHash(Symbol, String).new 3 | s[:key1] = "value1" 4 | s[:key2] = "value2" 5 | pp s.values 6 | 7 | # s.values # => ["value1", "value2"] 8 | -------------------------------------------------------------------------------- /String/ascii_only.cr: -------------------------------------------------------------------------------- 1 | pp "hoge".ascii_only? 2 | pp "".ascii_only? 3 | pp "ほげ".ascii_only? 4 | 5 | # "hoge".ascii_only? # => true 6 | # "".ascii_only? # => true 7 | # "ほげ".ascii_only? # => false 8 | -------------------------------------------------------------------------------- /String/bytes.cr: -------------------------------------------------------------------------------- 1 | pp "hoge".bytes 2 | pp "".bytes 3 | pp "ほげ".bytes 4 | 5 | # "hoge".bytes # => [104, 111, 103, 101] 6 | # "".bytes # => [] 7 | # "ほげ".bytes # => [227, 129, 187, 227, 129, 146] 8 | -------------------------------------------------------------------------------- /String/camelcase.cr: -------------------------------------------------------------------------------- 1 | pp "hoge".camelcase 2 | pp "hoge_hige".camelcase 3 | 4 | # "hoge".camelcase # => "Hoge" 5 | # "hoge_hige".camelcase # => "HogeHige" 6 | -------------------------------------------------------------------------------- /String/capitalize.cr: -------------------------------------------------------------------------------- 1 | pp "hoge".capitalize 2 | pp "hoge_hige".capitalize 3 | 4 | # "hoge".capitalize # => "Hoge" 5 | # "hoge_hige".capitalize # => "Hoge_hige" 6 | -------------------------------------------------------------------------------- /String/char_at.cr: -------------------------------------------------------------------------------- 1 | pp "hoge".char_at(1) 2 | pp "hoge".char_at(3) 3 | 4 | "hoge".char_at(1) # => 'o' 5 | "hoge".char_at(3) # => 'e' 6 | -------------------------------------------------------------------------------- /String/chars.cr: -------------------------------------------------------------------------------- 1 | pp "hoge".chars 2 | pp "ほげ".chars 3 | 4 | # "hoge".chars # => ['h', 'o', 'g', 'e'] 5 | # "ほげ".chars # => ['ほ', 'げ'] 6 | -------------------------------------------------------------------------------- /String/chomp.cr: -------------------------------------------------------------------------------- 1 | pp "hoge".chomp 2 | pp "hoge\n".chomp 3 | pp "hoge\n\n".chomp 4 | 5 | # "hoge".chomp # => "hoge" 6 | # "hoge\n".chomp # => "hoge" 7 | # "hoge\n\n".chomp # => "hoge\n" 8 | -------------------------------------------------------------------------------- /String/chop.cr: -------------------------------------------------------------------------------- 1 | pp "hoge".chop 2 | pp "hoge\n".chop 3 | pp "hoge\n\n".chop 4 | 5 | # "hoge".chop # => "hog" 6 | # "hoge\n".chop # => "hoge" 7 | # "hoge\n\n".chop # => "hoge\n" 8 | -------------------------------------------------------------------------------- /String/clone.cr: -------------------------------------------------------------------------------- 1 | hoge1 = "hoge" 2 | hoge2 = hoge1.clone 3 | pp hoge2 4 | pp hoge1 == hoge2 5 | 6 | # hoge2 # => "hoge" 7 | # hoge1 == hoge2 # => true 8 | -------------------------------------------------------------------------------- /String/codepoint_at.cr: -------------------------------------------------------------------------------- 1 | pp "hoge".codepoint_at(1) 2 | pp "hoge".codepoint_at(2) 3 | pp "ほげひげはげ".codepoint_at(1) 4 | pp "ほげひげはげ".codepoint_at(2) 5 | 6 | # "hoge".codepoint_at(1) # => 111 7 | # "hoge".codepoint_at(2) # => 103 8 | # "ほげひげはげ".codepoint_at(1) # => 12370 9 | # "ほげひげはげ".codepoint_at(2) # => 12402 10 | -------------------------------------------------------------------------------- /String/codepoints.cr: -------------------------------------------------------------------------------- 1 | pp "hoge".codepoints 2 | pp "ほげひげはげ".codepoints 3 | 4 | # "hoge".codepoints # => [104, 111, 103, 101] 5 | # "ほげひげはげ".codepoints # => [12411, 12370, 12402, 12370, 12399, 12370] 6 | -------------------------------------------------------------------------------- /String/compare.cr: -------------------------------------------------------------------------------- 1 | hoge = "hoge" 2 | pp hoge.compare("hoge", case_insensitive: true) 3 | pp hoge.compare("hoge", case_insensitive: false) 4 | pp hoge.compare("hoge") 5 | pp hoge.compare("HOGE", case_insensitive: true) 6 | pp hoge.compare("HOGE", case_insensitive: false) 7 | pp hoge.compare("HOGE") 8 | pp hoge.compare("zzz", case_insensitive: true) 9 | 10 | # hoge.compare("hoge", case_insensitive: true) # => 0 11 | # hoge.compare("hoge", case_insensitive: false) # => 0 12 | # hoge.compare("hoge") # => 0 13 | # hoge.compare("HOGE", case_insensitive: true) # => 0 14 | # hoge.compare("HOGE", case_insensitive: false) # => 1 15 | # hoge.compare("HOGE") # => 1 16 | # hoge.compare("zzz", case_insensitive: true) # => -1 17 | -------------------------------------------------------------------------------- /String/count.cr: -------------------------------------------------------------------------------- 1 | pp "hoge".count('h') 2 | pp "hogehigehage".count('h') 3 | pp "hogehigehage".count('z') 4 | 5 | # "hoge".count('h') # => 1 6 | # "hogehigehage".count('h') # => 3 7 | # "hogehigehage".count('z') # => 0 8 | -------------------------------------------------------------------------------- /String/delete.cr: -------------------------------------------------------------------------------- 1 | pp "HOGEhigehage".delete('h') 2 | pp "HOGEhigehage".delete("a-e") 3 | print "HOGEhigehage".bytes.map { |e|[e.unsafe_chr, e % 3] }, "\n" 4 | print "HOGEhigehage".delete { |e|e.bytes.first % 3 == 0 } 5 | 6 | # "HOGEhigehage".delete('h') # => "HOGEigeage" 7 | # "HOGEhigehage".delete("a-e") # => "HOGEhighg" 8 | # [['H', 0], ['O', 1], ['G', 2], ['E', 0], ['h', 2], ['i', 0], ['g', 1], ['e', 2], ['h', 2], ['a', 1], ['g', 1], ['e', 2]] 9 | # OGhgehage 10 | -------------------------------------------------------------------------------- /String/downcase.cr: -------------------------------------------------------------------------------- 1 | pp "HOGEhigehage".downcase 2 | pp "".downcase 3 | 4 | # "HOGEhigehage".downcase # => "hogehigehage" 5 | # "".downcase # => "" 6 | -------------------------------------------------------------------------------- /String/dump.cr: -------------------------------------------------------------------------------- 1 | pp "hoge".dump 2 | 3 | # "hoge".dump # => "\"hoge\"" 4 | -------------------------------------------------------------------------------- /String/each_byte.cr: -------------------------------------------------------------------------------- 1 | "hoge".each_byte { |e|pp e } 2 | 3 | # e # => 104 4 | # e # => 111 5 | # e # => 103 6 | # e # => 101 7 | -------------------------------------------------------------------------------- /String/each_char.cr: -------------------------------------------------------------------------------- 1 | "hoge".each_char { |e|pp e } 2 | 3 | # e # => 'h' 4 | # e # => 'o' 5 | # e # => 'g' 6 | # e # => 'e' 7 | -------------------------------------------------------------------------------- /String/each_codepoint.cr: -------------------------------------------------------------------------------- 1 | "hoge".each_codepoint { |e| pp e } 2 | "ほげ".each_codepoint { |e| pp e } 3 | 4 | # e # => 104 5 | # e # => 111 6 | # e # => 103 7 | # e # => 101 8 | # e # => 12411 9 | # e # => 12370 10 | -------------------------------------------------------------------------------- /String/each_line.cr: -------------------------------------------------------------------------------- 1 | str=<<-EOS 2 | line1 3 | line2 4 | line3 5 | line4 6 | EOS 7 | 8 | str.each_line { |e| pp e } 9 | 10 | # e # => "line1\n" 11 | # e # => "line2\n" 12 | # e # => "line3\n" 13 | # e # => "line4" 14 | -------------------------------------------------------------------------------- /String/empty.cr: -------------------------------------------------------------------------------- 1 | pp "hoge".empty? 2 | pp "".empty? 3 | 4 | # "hoge".empty? # => false 5 | # "".empty? # => true 6 | -------------------------------------------------------------------------------- /String/ends_with.cr: -------------------------------------------------------------------------------- 1 | pp "hoge".ends_with?('e') 2 | pp "hoge".ends_with?('g') 3 | pp "hoge".ends_with?("ge") 4 | pp "hoge".ends_with?("oe") 5 | pp "ほげ".ends_with?('げ') 6 | pp "ほげ".ends_with?('ほ') 7 | 8 | # "hoge".ends_with?('e') # => true 9 | # "hoge".ends_with?('g') # => false 10 | # "hoge".ends_with?("ge") # => true 11 | # "hoge".ends_with?("oe") # => false 12 | # "ほげ".ends_with?('げ') # => true 13 | # "ほげ".ends_with?('ほ') # => false 14 | -------------------------------------------------------------------------------- /String/eq.cr: -------------------------------------------------------------------------------- 1 | pp "hoge" == "hoge" 2 | hoge = "hoge" 3 | pp hoge == hoge 4 | pp hoge == "hige" 5 | 6 | # "hoge" == "hoge" # => true 7 | # hoge == hoge # => true 8 | # hoge == "hige" # => false -------------------------------------------------------------------------------- /String/eqc.cr: -------------------------------------------------------------------------------- 1 | pp "hogehigehage" =~ /h.ge/ 2 | pp "hogehigehage" =~ /(h.ge)(h.ge)(h.ge)/ 3 | pp $1, $2, $3 4 | pp "hogehigehage" =~ /bar/ 5 | 6 | # "hogehigehage" =~ (/h.ge/) # => 0 7 | # "hogehigehage" =~ (/(h.ge)(h.ge)(h.ge)/) # => 0 8 | # $~[1] # => "hoge" 9 | # $~[2] # => "hige" 10 | # $~[3] # => "hage" 11 | # "hogehigehage" =~ (/bar/) # => nil 12 | -------------------------------------------------------------------------------- /String/gsub.cr: -------------------------------------------------------------------------------- 1 | pp "hogehigehage".gsub('h', "**") 2 | pp "hogehigehage".gsub(/h.ge/) { |e|e.capitalize } 3 | pp "hogehigehage".gsub("ge") { |e|e.capitalize } 4 | pp "hogehigehage".gsub("ge", "**") 5 | pp "hogehigehage".gsub({'h' => '*', 'g' => "##"}) 6 | 7 | # "hogehigehage".gsub('h', "**") # => "**oge**ige**age" 8 | # "hogehigehage".gsub(/h.ge/, &.capitalize) # => "HogeHigeHage" 9 | # "hogehigehage".gsub("ge", &.capitalize) # => "hoGehiGehaGe" 10 | # "hogehigehage".gsub("ge", "**") # => "ho**hi**ha**" 11 | # "hogehigehage".gsub({'h' => '*', 'g' => "##"}) # => "*o##e*i##e*a##e" 12 | -------------------------------------------------------------------------------- /String/includes.cr: -------------------------------------------------------------------------------- 1 | pp "hoge".includes?("og") 2 | pp "hoge".includes?("invalid") 3 | 4 | # "hoge".includes?("og") # => true 5 | # "hoge".includes?("invalid") # => false 6 | -------------------------------------------------------------------------------- /String/index.cr: -------------------------------------------------------------------------------- 1 | pp "hogehigehage".index('h') # char 2 | pp "hogehigehage".index('h', 1) # char with offset 3 | pp "hogehigehage".index('z') # char not exist 4 | pp "hogehigehage".index("ge") # string 5 | pp "hogehigehage".index("ge", 5) # string with offset 6 | pp "hogehigehage".index("invalid") # string not exist 7 | 8 | # "hogehigehage".index('h') # => 0 9 | # "hogehigehage".index('h', 1) # => 4 10 | # "hogehigehage".index('z') # => nil 11 | # "hogehigehage".index("ge") # => 2 12 | # "hogehigehage".index("ge", 5) # => 6 13 | # "hogehigehage".index("invalid") # => nil 14 | -------------------------------------------------------------------------------- /String/insert.cr: -------------------------------------------------------------------------------- 1 | pp "hogehigehage".insert(1, '*') # char 2 | pp "hogehigehage".insert(1, "**") # char 3 | 4 | # "hogehigehage".insert(1, '*') # => "h*ogehigehage" 5 | # "hogehigehage".insert(1, "**") # => "h**ogehigehage" 6 | -------------------------------------------------------------------------------- /String/lines.cr: -------------------------------------------------------------------------------- 1 | pp "hoge\nhige\nhage".lines 2 | pp "hoge".lines 3 | 4 | # "hoge\nhige\nhage".lines # => ["hoge\n", "hige\n", "hage"] 5 | # "hoge".lines # => ["hoge"] 6 | -------------------------------------------------------------------------------- /String/ljust.cr: -------------------------------------------------------------------------------- 1 | pp "hoge".ljust(10) 2 | pp "hoge".ljust(10, '*') 3 | 4 | # "hoge".ljust(10) # => "hoge " 5 | # "hoge".ljust(10, '*') # => "hoge******" 6 | -------------------------------------------------------------------------------- /String/lstrip.cr: -------------------------------------------------------------------------------- 1 | pp " hoge".lstrip 2 | pp "hoge ".lstrip 3 | pp "hoge".lstrip 4 | 5 | # " hoge".lstrip # => "hoge" 6 | # "hoge ".lstrip # => "hoge " 7 | # "hoge".lstrip # => "hoge" 8 | -------------------------------------------------------------------------------- /String/lteqgt.cr: -------------------------------------------------------------------------------- 1 | pp "a" <=> "b" 2 | pp "b" <=> "b" 3 | pp "b" <=> "a" 4 | 5 | # "a" <=> "b" # => -1 6 | # "b" <=> "b" # => 0 7 | # "b" <=> "a" # => 1 8 | -------------------------------------------------------------------------------- /String/multiply.cr: -------------------------------------------------------------------------------- 1 | pp "hoge" * 2 2 | pp "hoge" * 4 3 | 4 | # "hoge" * 2 # => "hogehoge" 5 | # "hoge" * 4 # => "hogehogehogehoge" 6 | -------------------------------------------------------------------------------- /String/percent.cr: -------------------------------------------------------------------------------- 1 | pp "My name is %s. I'm %d years old" % ["tanaka" , 23] 2 | pp "My name is %s. I'm %d years old" % ["suzuki" , 32] 3 | 4 | # "My name is %s. I'm %d years old" % ["tanaka", 23] # => "My name is tanaka. I'm 23 years old" 5 | # "My name is %s. I'm %d years old" % ["suzuki", 32] # => "My name is suzuki. I'm 32 years old" 6 | -------------------------------------------------------------------------------- /String/plus.cr: -------------------------------------------------------------------------------- 1 | pp "hoge" + "hige" 2 | pp "hoge" + "hage" 3 | 4 | # "hoge" + "hige" # => "hogehige" 5 | # "hoge" + "hage" # => "hogehage" 6 | -------------------------------------------------------------------------------- /String/reverse.cr: -------------------------------------------------------------------------------- 1 | pp "hoge".reverse 2 | 3 | # "hoge".reverse # => "egoh" 4 | -------------------------------------------------------------------------------- /String/rindex.cr: -------------------------------------------------------------------------------- 1 | pp "hogehigehage".rindex('h') # char 2 | pp "hogehigehage".rindex('h', 1) # char with offset 3 | pp "hogehigehage".rindex('z') # char not exist 4 | pp "hogehigehage".rindex("ge") # string 5 | pp "hogehigehage".rindex("ge", 5) # string with offset 6 | pp "hogehigehage".rindex("invalid") # string not exist 7 | 8 | # "hogehigehage".rindex('h') # => 8 9 | # "hogehigehage".rindex('h', 1) # => 0 10 | # "hogehigehage".rindex('z') # => nil 11 | # "hogehigehage".rindex("ge") # => 10 12 | # "hogehigehage".rindex("ge", 5) # => 2 13 | # "hogehigehage".rindex("invalid") # => nil 14 | -------------------------------------------------------------------------------- /String/rjust.cr: -------------------------------------------------------------------------------- 1 | pp "hoge".rjust(10) 2 | pp "hoge".rjust(10, '*') 3 | 4 | # "hoge".rjust(10) # => " hoge" 5 | # "hoge".rjust(10, '*') # => "******hoge" 6 | -------------------------------------------------------------------------------- /String/rstrip.cr: -------------------------------------------------------------------------------- 1 | pp " hoge".rstrip 2 | pp "hoge ".rstrip 3 | pp "hoge".rstrip 4 | 5 | # " hoge".rstrip # => " hoge" 6 | # "hoge ".rstrip # => "hoge" 7 | # "hoge".rstrip # => "hoge" 8 | -------------------------------------------------------------------------------- /String/scan.cr: -------------------------------------------------------------------------------- 1 | pp "hogehigehage".scan(/h.ge/) 2 | pp "hogehigehage".scan(/(?h.ge)/) # named capture 3 | pp "hogehigehage".scan(/not match/) 4 | 5 | # "hogehigehage".scan(/h.ge/) # => [#, #, #] 6 | # "hogehigehage".scan(/(?h.ge)/) # => [#, #, #] 7 | # "hogehigehage".scan(/not match/) # => [] 8 | -------------------------------------------------------------------------------- /String/size.cr: -------------------------------------------------------------------------------- 1 | pp "hoge".size 2 | pp "".size 3 | 4 | # "hoge".size # => 4 5 | # "".size # => 0 6 | -------------------------------------------------------------------------------- /String/square_bracket.cr: -------------------------------------------------------------------------------- 1 | pp "hoge"[0] 2 | pp "hoge"[1] 3 | pp "hoge"[-1] 4 | pp "hoge"[1..2] 5 | 6 | # "hoge"[0] # => 'h' 7 | # "hoge"[1] # => 'o' 8 | # "hoge"[-1] # => 'e' 9 | # "hoge"[1..2] # => "og" 10 | -------------------------------------------------------------------------------- /String/square_bracket_q.cr: -------------------------------------------------------------------------------- 1 | pp "hoge"["h"]? 2 | pp "hoge"["og"]? 3 | pp "hoge"["z"]? 4 | 5 | # "hoge"["h"]? # => "h" 6 | # "hoge"["og"]? # => "og" 7 | # "hoge"["z"]? # => nil 8 | -------------------------------------------------------------------------------- /String/squeeze.cr: -------------------------------------------------------------------------------- 1 | pp "UUURYYY!".squeeze('Y') 2 | pp "UUURYYY!".squeeze{|e|['U', 'Y'].includes?(e)} 3 | 4 | # "UUURYYY!".squeeze('Y') # => "UUURY!" 5 | # "UUURYYY!".squeeze do |e| 6 | # ['U', 'Y'].includes?(e) 7 | # end # => "URY!" 8 | -------------------------------------------------------------------------------- /String/starts_with.cr: -------------------------------------------------------------------------------- 1 | pp "UUURYYY!".starts_with?('U') 2 | pp "UUURYYY!".starts_with?('V') 3 | pp "UUURYYY!".starts_with?("UUX") 4 | pp "UUURYYY!".starts_with?("UUU") 5 | 6 | # "UUURYYY!".starts_with?('U') # => true 7 | # "UUURYYY!".starts_with?('V') # => false 8 | # "UUURYYY!".starts_with?("UUX") # => false 9 | # "UUURYYY!".starts_with?("UUU") # => true 10 | -------------------------------------------------------------------------------- /String/strip.cr: -------------------------------------------------------------------------------- 1 | pp " hoge".strip 2 | pp "hoge ".strip 3 | pp "hoge".strip 4 | 5 | # " hoge".strip # => "hoge" 6 | # "hoge ".strip # => "hoge" 7 | # "hoge".strip # => "hoge" 8 | -------------------------------------------------------------------------------- /String/sub.cr: -------------------------------------------------------------------------------- 1 | pp "hogehigehage".sub('h', '*') 2 | pp "hogehigehage".sub(/h.ge/) { |e|e.capitalize } 3 | pp "hogehigehage".sub("ge") { |e|e.capitalize } 4 | pp "hogehigehage".sub("ge", "**") 5 | pp "hogehigehage".sub({'h' => '*', 'g' => "##"}) 6 | 7 | # "hogehigehage".sub('h', '*') # => "*ogehigehage" 8 | # "hogehigehage".sub(/h.ge/, &.capitalize) # => "Hogehigehage" 9 | # "hogehigehage".sub("ge", &.capitalize) # => "hoGehigehage" 10 | # "hogehigehage".sub("ge", "**") # => "ho**higehage" 11 | # "hogehigehage".sub({'h' => '*', 'g' => "##"}) # => "*ogehigehage" 12 | -------------------------------------------------------------------------------- /String/succ.cr: -------------------------------------------------------------------------------- 1 | pp "hoge".size 2 | pp "".size 3 | 4 | # "hoge".size # => 4 5 | # "".size # => 0 6 | -------------------------------------------------------------------------------- /String/to_f.cr: -------------------------------------------------------------------------------- 1 | pp "1.23".to_f 2 | pp "1".to_f 3 | pp "a".to_f 4 | 5 | # "1.23".to_f # => 1.23 6 | # "1".to_f # => 1.0 7 | # "a".to_f # => 0.0 8 | -------------------------------------------------------------------------------- /String/to_i.cr: -------------------------------------------------------------------------------- 1 | pp "101".to_i 2 | pp "101".to_i(2) 3 | pp "101".to_i(8) 4 | pp "101".to_i(16) 5 | 6 | # "101".to_i # => 101 7 | # "101".to_i(2) # => 5 8 | # "101".to_i(8) # => 65 9 | # "101".to_i(16) # => 257 10 | -------------------------------------------------------------------------------- /String/to_slice.cr: -------------------------------------------------------------------------------- 1 | pp "hoge".to_slice 2 | pp "".to_slice 3 | 4 | # "hoge".to_slice # => Slice[104, 111, 103, 101] 5 | # "".to_slice # => Slice[] 6 | -------------------------------------------------------------------------------- /String/tr.cr: -------------------------------------------------------------------------------- 1 | pp "hogehige".tr("hg", "+-") 2 | pp "hogehige".tr("h", "+") 3 | pp "hogehige".tr("h", "+-") 4 | 5 | # "hogehige".tr("hg", "+-") # => "+o-e+i-e" 6 | # "hogehige".tr("h", "+") # => "+oge+ige" 7 | # "hogehige".tr("h", "+-") # => "+oge+ige" 8 | -------------------------------------------------------------------------------- /String/underscore.cr: -------------------------------------------------------------------------------- 1 | pp "HoGe".underscore 2 | pp "hOGe".underscore 3 | 4 | "HoGe".underscore # => "ho_ge" 5 | "hOGe".underscore # => "h_o_ge" 6 | -------------------------------------------------------------------------------- /String/upcase.cr: -------------------------------------------------------------------------------- 1 | pp "HoGe".upcase 2 | pp "hOGe".upcase 3 | 4 | # "HoGe".upcase # => "HOGE" 5 | # "hOGe".upcase # => "HOGE" 6 | -------------------------------------------------------------------------------- /StringPool/get.cr: -------------------------------------------------------------------------------- 1 | require "string_pool" 2 | 3 | pool = StringPool.new 4 | a = "hoge" + "hage" 5 | b = "hoge" + "hage" 6 | pp a.same?(b) 7 | c = pool.get(a) 8 | d = pool.get(b) 9 | pp c.same?(d) 10 | 11 | # a.same?(b) # => false 12 | # c.same?(d) # => true 13 | -------------------------------------------------------------------------------- /StringScanner/bracket.cr: -------------------------------------------------------------------------------- 1 | require "string_scanner" 2 | 3 | s = StringScanner.new("hogehigehage") 4 | s.scan(/(h.ge)(h.ge)(h.ge)/) 5 | 6 | puts "StringScanner#[]" 7 | 4.times {|i|pp s[i]} 8 | 9 | puts "StringScanner#[]?" 10 | 5.times {|i|pp s[i]?} 11 | 12 | # a.same?(b) # => false 13 | # c.same?(d) # => true 14 | -------------------------------------------------------------------------------- /StringScanner/check.cr: -------------------------------------------------------------------------------- 1 | require "string_scanner" 2 | 3 | s = StringScanner.new("hoge hige hage") 4 | pp s.check(/\w+/) 5 | s.offset = 5 6 | pp s.check(/\w+/) 7 | pp s.check(/\w+/) 8 | 9 | # s.check(/\w+/) # => "hoge" 10 | # s.check(/\w+/) # => "hige" 11 | # s.check(/\w+/) # => "hige" 12 | -------------------------------------------------------------------------------- /StringScanner/eos.cr: -------------------------------------------------------------------------------- 1 | require "string_scanner" 2 | 3 | s = StringScanner.new("hoge hige hage") 4 | pp s.eos? 5 | s.scan(/(h.ge+\s?){3}/) 6 | pp s 7 | pp s.eos? 8 | 9 | # s.eos? # => false 10 | # s # => # 11 | # s.eos? # => true 12 | -------------------------------------------------------------------------------- /StringScanner/offset.cr: -------------------------------------------------------------------------------- 1 | require "string_scanner" 2 | 3 | s = StringScanner.new("hoge hige hage") 4 | pp s.offset 5 | pp s.scan(/h.ge/) 6 | pp s.offset 7 | 8 | # s.offset # => 0 9 | # s.scan(/h.ge/) # => "hoge" 10 | # s.offset # => 4 11 | 12 | -------------------------------------------------------------------------------- /StringScanner/peek.cr: -------------------------------------------------------------------------------- 1 | require "string_scanner" 2 | 3 | s = StringScanner.new("hoge hige hage") 4 | pp s.peek(0) 5 | pp s.peek(4) 6 | 7 | # s.peek(0) # => "" 8 | # s.peek(4) # => "hoge" 9 | -------------------------------------------------------------------------------- /StringScanner/reset.cr: -------------------------------------------------------------------------------- 1 | require "string_scanner" 2 | 3 | s = StringScanner.new("hoge hige hage") 4 | pp s.offset 5 | pp s.scan(/h.ge/) 6 | pp s.offset 7 | pp s.reset 8 | pp s.offset 9 | 10 | # s.offset # => 0 11 | # s.scan(/h.ge/) # => "hoge" 12 | # s.offset # => 4 13 | # s.reset # => 0 14 | # s.offset # => 0 15 | -------------------------------------------------------------------------------- /StringScanner/rest.cr: -------------------------------------------------------------------------------- 1 | require "string_scanner" 2 | 3 | s = StringScanner.new("hoge hige hage") 4 | pp s.rest 5 | pp s.scan(/\w+/) 6 | pp s.rest 7 | 8 | # s.rest # => "hoge hige hage" 9 | # s.scan(/\w+/) # => nil 10 | # s.rest # => " hige hage" 11 | -------------------------------------------------------------------------------- /StringScanner/scan.cr: -------------------------------------------------------------------------------- 1 | require "string_scanner" 2 | 3 | s = StringScanner.new("hoge hige hage") 4 | pp s.offset 5 | pp s.scan(/\s?h.ge/) 6 | pp s.offset 7 | pp s.scan(/\s?h.ge/) 8 | pp s.offset 9 | 10 | # s.offset # => 0 11 | # s.scan(/\s?h.ge/) # => " hige" 12 | # s.offset # => 9 13 | # s.scan(/\s?h.ge/) # => nil 14 | # s.offset # => 14 15 | -------------------------------------------------------------------------------- /StringScanner/skip.cr: -------------------------------------------------------------------------------- 1 | require "string_scanner" 2 | 3 | s = StringScanner.new("hoge hige hage") 4 | pp s.offset 5 | pp s.skip(/\s?h.ge/) 6 | pp s.offset 7 | pp s.skip(/\s?h.ge/) 8 | pp s.offset 9 | 10 | # s.offset # => 0 11 | # s.skip(/\s?h.ge/) # => 4 12 | # s.offset # => 4 13 | # s.skip(/\s?h.ge/) # => 5 14 | # s.offset # => 9 15 | -------------------------------------------------------------------------------- /StringScanner/string.cr: -------------------------------------------------------------------------------- 1 | require "string_scanner" 2 | 3 | s = StringScanner.new("hoge hige hage") 4 | pp s.scan(/hige/) 5 | pp s.string 6 | 7 | # s.scan(/hige/) # => nil 8 | # s.string # => "hoge hige hage" 9 | -------------------------------------------------------------------------------- /Struct/eqeq.cr: -------------------------------------------------------------------------------- 1 | struct Person 2 | @name : String 3 | @age : Int32 4 | def initialize(@name, @age) 5 | end 6 | end 7 | 8 | tanaka1 = Person.new("Tanaka", 23) 9 | suzuki = Person.new("Suzuki", 32) 10 | tanaka2 = Person.new("Tanaka", 23) 11 | 12 | pp tanaka1 == suzuki 13 | pp tanaka1 == tanaka2 14 | 15 | # tanaka1 == suzuki # => false 16 | # tanaka1 == tanaka2 # => true 17 | -------------------------------------------------------------------------------- /Struct/hash.cr: -------------------------------------------------------------------------------- 1 | struct Person 2 | @name : String 3 | @age : Int32 4 | def initialize(@name, @age) 5 | end 6 | end 7 | 8 | tanaka1 = Person.new("Tanaka", 23) 9 | suzuki = Person.new("Suzuki", 32) 10 | tanaka2 = Person.new("Tanaka", 23) 11 | 12 | pp tanaka1.hash 13 | pp suzuki.hash 14 | pp tanaka2.hash 15 | 16 | # tanaka1.hash # => 122508417 17 | # suzuki.hash # => -180733915 18 | # tanaka2.hash # => 122508417 19 | -------------------------------------------------------------------------------- /Struct/inspect.cr: -------------------------------------------------------------------------------- 1 | struct Person 2 | @name : String 3 | @age : Int32 4 | def initialize(@name, @age) 5 | end 6 | end 7 | 8 | tanaka1 = Person.new("Tanaka", 23) 9 | 10 | pp tanaka1.inspect 11 | 12 | # tanaka1.inspect # => "Person(@name=\"Tanaka\", @age=23)" 13 | -------------------------------------------------------------------------------- /Symbol/clone.cr: -------------------------------------------------------------------------------- 1 | a = :hoge 2 | b = a.clone 3 | pp a == :hoge 4 | pp a == b 5 | 6 | # a == (:hoge) # => true 7 | # a == b # => true 8 | -------------------------------------------------------------------------------- /Symbol/compare.cr: -------------------------------------------------------------------------------- 1 | pp :hoge <=> :hoge 2 | pp :hoge <=> :hige 3 | pp :hige <=> :hoge 4 | 5 | # (:hoge) <=> (:hoge) # => 0 6 | # (:hoge) <=> (:hige) # => 1 7 | # (:hige) <=> (:hoge) # => -1 8 | -------------------------------------------------------------------------------- /Symbol/eq.cr: -------------------------------------------------------------------------------- 1 | pp :hoge == :hoge 2 | pp :hoge == :hige 3 | 4 | # (:hoge) == (:hoge) # => true 5 | # (:hoge) == (:hige) # => false 6 | -------------------------------------------------------------------------------- /Symbol/hash.cr: -------------------------------------------------------------------------------- 1 | pp :hoge.hash 2 | pp :hoge.hash 3 | pp :hige.hash 4 | 5 | # (:hoge).hash # => 1 6 | # (:hoge).hash # => 1 7 | # (:hige).hash # => 2 8 | -------------------------------------------------------------------------------- /Symbol/inspect.cr: -------------------------------------------------------------------------------- 1 | pp :hoge.inspect 2 | pp :hige.inspect 3 | 4 | # (:hoge).inspect # => ":hoge" 5 | # (:hige).inspect # => ":hige" 6 | -------------------------------------------------------------------------------- /Symbol/not_eq.cr: -------------------------------------------------------------------------------- 1 | pp :hoge == :hoge 2 | pp :hoge == :hige 3 | 4 | # (:hoge) == (:hoge) # => true 5 | # (:hoge) == (:hige) # => false 6 | -------------------------------------------------------------------------------- /Symbol/to_i.cr: -------------------------------------------------------------------------------- 1 | pp :hoge.to_i 2 | pp :hoge.hash 3 | pp :hige.to_i 4 | pp :hige.hash 5 | 6 | # (:hoge).to_i # => 1 7 | # (:hoge).hash # => 1 8 | # (:hige).to_i # => 2 9 | # (:hige).hash # => 2 10 | -------------------------------------------------------------------------------- /Symbol/to_s.cr: -------------------------------------------------------------------------------- 1 | a = :hoge 2 | b = a.clone 3 | pp a == :hoge 4 | pp a == b 5 | 6 | # a == (:hoge) # => true 7 | # a == b # => true 8 | -------------------------------------------------------------------------------- /Time/add_ticks.cr: -------------------------------------------------------------------------------- 1 | pp Time.now.add_ticks(100_000_000_i64) 2 | pp Time.now.add_ticks(200_000_000_i64) 3 | 4 | # Time.now.add_ticks(100000000_i64) # => 2016-10-16 16:55:48 +0000 5 | # Time.now.add_ticks(200000000_i64) # => 2016-10-16 16:55:58 +0000 -------------------------------------------------------------------------------- /Time/at_beginning_of_day.cr: -------------------------------------------------------------------------------- 1 | pp Time.new(2016, 1, 2, 3, 4, 5).at_beginning_of_day 2 | 3 | # (Time.new(2016, 1, 2, 3, 4, 5)).at_beginning_of_day # => 2016-01-02 00:00:00 4 | -------------------------------------------------------------------------------- /Time/at_beginning_of_hour.cr: -------------------------------------------------------------------------------- 1 | pp Time.new(2016, 1, 2, 3, 4, 5).at_beginning_of_hour 2 | 3 | # (Time.new(2016, 1, 2, 3, 4, 5)).at_beginning_of_day # => 2016-01-02 03:00:00 4 | -------------------------------------------------------------------------------- /Time/at_beginning_of_minute.cr: -------------------------------------------------------------------------------- 1 | pp Time.new(2016, 1, 2, 3, 4, 5).at_beginning_of_minute 2 | 3 | # (Time.new(2016, 1, 2, 3, 4, 5)).at_beginning_of_minute # => 2016-01-02 03:04:00 4 | -------------------------------------------------------------------------------- /Time/at_beginning_of_month.cr: -------------------------------------------------------------------------------- 1 | pp Time.new(2016, 1, 2, 3, 4, 5).at_beginning_of_month 2 | 3 | # (Time.new(2016, 1, 2, 3, 4, 5)).at_beginning_of_month # => 2016-01-01 00:00:00 4 | -------------------------------------------------------------------------------- /Time/at_beginning_of_quarter.cr: -------------------------------------------------------------------------------- 1 | pp Time.new(2016, 2, 3, 4, 5, 6).at_beginning_of_quarter 2 | pp Time.new(2016, 11, 3, 4, 5, 6).at_beginning_of_quarter 3 | 4 | # (Time.new(2016, 2, 3, 4, 5, 6)).at_beginning_of_quarter # => 2016-01-01 00:00:00 5 | # (Time.new(2016, 11, 3, 4, 5, 6)).at_beginning_of_quarter # => 2016-10-01 00:00:00 6 | -------------------------------------------------------------------------------- /Time/at_beginning_of_semester.cr: -------------------------------------------------------------------------------- 1 | pp Time.new(2016, 2, 3, 4, 5, 1).at_beginning_of_semester 2 | pp Time.new(2016, 8, 3, 4, 5, 1).at_beginning_of_semester 3 | 4 | # (Time.new(2016, 2, 3, 4, 5, 1)).at_beginning_of_semester # => 2016-01-01 00:00:00 5 | # (Time.new(2016, 8, 3, 4, 5, 1)).at_beginning_of_semester # => 2016-07-01 00:00:00 6 | -------------------------------------------------------------------------------- /Time/at_beginning_of_week.cr: -------------------------------------------------------------------------------- 1 | pp Time.new(2016, 1, 2, 3, 4, 5).at_beginning_of_week 2 | pp Time.new(2016, 1, 10, 3, 4, 5).at_beginning_of_week 3 | 4 | # (Time.new(2016, 1, 2, 3, 4, 5)).at_beginning_of_week # => 2015-12-28 00:00:00 5 | # (Time.new(2016, 1, 10, 3, 4, 5)).at_beginning_of_week # => 2016-01-04 00:00:00 6 | -------------------------------------------------------------------------------- /Time/at_beginning_of_year.cr: -------------------------------------------------------------------------------- 1 | pp Time.new(2016, 1, 2, 3, 4, 5).at_beginning_of_month 2 | 3 | # (Time.new(2016, 1, 2, 3, 4, 5)).at_beginning_of_month # => 2016-01-01 00:00:00 4 | -------------------------------------------------------------------------------- /Time/at_end_of_day.cr: -------------------------------------------------------------------------------- 1 | pp Time.new(2016, 1, 2, 3, 4, 5).at_end_of_day 2 | 3 | # (Time.new(2016, 1, 2, 3, 4, 5)).at_end_of_day # => 2016-01-02 23:59:59 4 | -------------------------------------------------------------------------------- /Time/at_end_of_hour.cr: -------------------------------------------------------------------------------- 1 | pp Time.new(2016, 1, 2, 3, 4, 5) 2 | pp Time.new(2016, 1, 2, 3, 4, 5).at_end_of_hour 3 | 4 | # Time.new(2016, 1, 2, 3, 4, 5) # => 2016-01-02 03:04:05 5 | # (Time.new(2016, 1, 2, 3, 4, 5)).at_end_of_hour # => 2016-01-02 03:59:59 6 | -------------------------------------------------------------------------------- /Time/at_end_of_minute.cr: -------------------------------------------------------------------------------- 1 | pp Time.new(2016, 1, 2, 3, 4, 5) 2 | pp Time.new(2016, 1, 2, 3, 4, 5).at_end_of_minute 3 | 4 | # Time.new(2016, 1, 2, 3, 4, 5) # => 2016-01-02 03:04:05 5 | # (Time.new(2016, 1, 2, 3, 4, 5)).at_end_of_minute # => 2016-01-02 03:04:59 6 | -------------------------------------------------------------------------------- /Time/at_end_of_month.cr: -------------------------------------------------------------------------------- 1 | pp Time.new(2016, 1, 2, 3, 4, 5) 2 | pp Time.new(2016, 1, 2, 3, 4, 5).at_end_of_month 3 | 4 | # Time.new(2016, 1, 2, 3, 4, 5) # => 2016-01-02 03:04:05 5 | # (Time.new(2016, 1, 2, 3, 4, 5)).at_end_of_month # => 2016-01-31 23:59:59 6 | -------------------------------------------------------------------------------- /Time/at_end_of_quarter.cr: -------------------------------------------------------------------------------- 1 | pp Time.new(2016, 1, 2, 3, 4, 5) 2 | pp Time.new(2016, 1, 2, 3, 4, 5).at_end_of_quarter 3 | 4 | Time.new(2016, 1, 2, 3, 4, 5) # => 2016-01-02 03:04:05 5 | (Time.new(2016, 1, 2, 3, 4, 5)).at_end_of_quarter # => 2016-03-31 23:59:59 -------------------------------------------------------------------------------- /Time/at_end_of_semester.cr: -------------------------------------------------------------------------------- 1 | pp Time.new(2016, 1, 2, 3, 4, 5) 2 | pp Time.new(2016, 1, 2, 3, 4, 5).at_end_of_semester 3 | 4 | # Time.new(2016, 1, 2, 3, 4, 5) # => 2016-01-02 03:04:05 5 | # (Time.new(2016, 1, 2, 3, 4, 5)).at_end_of_semester # => 2016-06-30 23:59:59 6 | -------------------------------------------------------------------------------- /Time/at_end_of_week.cr: -------------------------------------------------------------------------------- 1 | pp Time.new(2016, 1, 2, 3, 4, 5) 2 | pp Time.new(2016, 1, 2, 3, 4, 5).at_end_of_week 3 | 4 | # Time.new(2016, 1, 2, 3, 4, 5) # => 2016-01-02 03:04:05 5 | # (Time.new(2016, 1, 2, 3, 4, 5)).at_end_of_week # => 2016-01-03 23:59:59 6 | -------------------------------------------------------------------------------- /Time/at_end_of_year.cr: -------------------------------------------------------------------------------- 1 | pp Time.new(2016, 1, 2, 3, 4, 5) 2 | pp Time.new(2016, 1, 2, 3, 4, 5).at_end_of_year 3 | 4 | # Time.new(2016, 1, 2, 3, 4, 5) # => 2016-01-02 03:04:05 5 | # (Time.new(2016, 1, 2, 3, 4, 5)).at_end_of_year # => 2016-12-31 23:59:59 6 | -------------------------------------------------------------------------------- /Time/at_midday.cr: -------------------------------------------------------------------------------- 1 | pp Time.new(2016, 1, 2, 3, 4, 5) 2 | pp Time.new(2016, 1, 2, 3, 4, 5).at_midday 3 | 4 | # Time.new(2016, 1, 2, 3, 4, 5) # => 2016-01-02 03:04:05 5 | # (Time.new(2016, 1, 2, 3, 4, 5)).at_midday # => 2016-01-02 12:00:00 6 | -------------------------------------------------------------------------------- /Time/cmp.cr: -------------------------------------------------------------------------------- 1 | pp Time.epoch(900_000_000) <=> Time.epoch(900_000_000) 2 | pp (Time.now + Time::MonthSpan.new(1)) <=> Time.now 3 | pp (Time.now - Time::MonthSpan.new(1)) <=> Time.now 4 | 5 | # (Time.epoch(900000000)) <=> (Time.epoch(900000000)) # => 0 6 | # (Time.now + (Time::MonthSpan.new(1))) <=> Time.now # => 1 7 | # (Time.now - (Time::MonthSpan.new(1))) <=> Time.now # => -1 8 | -------------------------------------------------------------------------------- /Time/date.cr: -------------------------------------------------------------------------------- 1 | pp Time.new(2016, 1, 2, 3, 4, 5) 2 | pp Time.new(2016, 1, 2, 3, 4, 5).date 3 | 4 | # Time.new(2016, 1, 2, 3, 4, 5) # => 2016-01-02 03:04:05 5 | # (Time.new(2016, 1, 2, 3, 4, 5)).date # => 2016-01-02 00:00:00 6 | -------------------------------------------------------------------------------- /Time/day_of_week.cr: -------------------------------------------------------------------------------- 1 | (1..7).each{|e|pp Time.new(2016, 1, e, 3, 4, 5).day_of_week} 2 | 3 | # (Time.new(2016, 1, e, 3, 4, 5)).day_of_week # => Friday 4 | # (Time.new(2016, 1, e, 3, 4, 5)).day_of_week # => Saturday 5 | # (Time.new(2016, 1, e, 3, 4, 5)).day_of_week # => Sunday 6 | # (Time.new(2016, 1, e, 3, 4, 5)).day_of_week # => Monday 7 | # (Time.new(2016, 1, e, 3, 4, 5)).day_of_week # => Tuesday 8 | # (Time.new(2016, 1, e, 3, 4, 5)).day_of_week # => Wednesday 9 | # (Time.new(2016, 1, e, 3, 4, 5)).day_of_week # => Thursday 10 | -------------------------------------------------------------------------------- /Time/day_of_year.cr: -------------------------------------------------------------------------------- 1 | (1..7).each{|e|pp Time.new(2016, 1, e, 3, 4, 5).day_of_year} 2 | 3 | # (Time.new(2016, 1, e, 3, 4, 5)).day_of_year # => 1 4 | # (Time.new(2016, 1, e, 3, 4, 5)).day_of_year # => 2 5 | # (Time.new(2016, 1, e, 3, 4, 5)).day_of_year # => 3 6 | # (Time.new(2016, 1, e, 3, 4, 5)).day_of_year # => 4 7 | # (Time.new(2016, 1, e, 3, 4, 5)).day_of_year # => 5 8 | # (Time.new(2016, 1, e, 3, 4, 5)).day_of_year # => 6 9 | # (Time.new(2016, 1, e, 3, 4, 5)).day_of_year # => 7 10 | -------------------------------------------------------------------------------- /Time/epoch.cr: -------------------------------------------------------------------------------- 1 | [300_000_000, 350_000_000].each {|e| 2 | pp Time.epoch(e) 3 | } 4 | 5 | # Time.epoch(e) # => 1979-07-05 05:20:00 UTC 6 | # Time.epoch(e) # => 1981-02-02 22:13:20 UTC 7 | -------------------------------------------------------------------------------- /Time/epoch_ms.cr: -------------------------------------------------------------------------------- 1 | [300_000_000_000, 350_000_000_000].each {|e| 2 | pp Time.epoch_ms(e) 3 | } 4 | 5 | # Time.epoch_ms(e) # => 1979-07-05 05:20:00 UTC 6 | # Time.epoch_ms(e) # => 1981-02-02 22:13:20 UTC 7 | -------------------------------------------------------------------------------- /Time/friday.cr: -------------------------------------------------------------------------------- 1 | (1..7).each {|e| 2 | pp e 3 | pp Time.new(2016, 1, e, 3, 4, 5).friday? 4 | } 5 | 6 | 7 | # e # => 1 8 | # (Time.new(2016, 1, e, 3, 4, 5)).friday? # => true 9 | # e # => 2 10 | # (Time.new(2016, 1, e, 3, 4, 5)).friday? # => false 11 | # e # => 3 12 | # (Time.new(2016, 1, e, 3, 4, 5)).friday? # => false 13 | # e # => 4 14 | # (Time.new(2016, 1, e, 3, 4, 5)).friday? # => false 15 | # e # => 5 16 | # (Time.new(2016, 1, e, 3, 4, 5)).friday? # => false 17 | # e # => 6 18 | # (Time.new(2016, 1, e, 3, 4, 5)).friday? # => false 19 | # e # => 7 20 | # (Time.new(2016, 1, e, 3, 4, 5)).friday? # => false 21 | -------------------------------------------------------------------------------- /Time/kind.cr: -------------------------------------------------------------------------------- 1 | pp Time.new(2016, 1, 2).kind 2 | pp Time.new(2016, 1, 2).to_utc.kind 3 | pp Time.new(2016, 1, 2).to_local.kind 4 | 5 | # (Time.new(2016, 1, 2)).kind # => Unspecified 6 | # (Time.new(2016, 1, 2)).to_utc.kind # => Utc 7 | # (Time.new(2016, 1, 2)).to_local.kind # => Local 8 | -------------------------------------------------------------------------------- /Time/leap_year.cr: -------------------------------------------------------------------------------- 1 | [2015, 2016].each {|e|pp Time.leap_year?(e)} 2 | 3 | # Time.leap_year?(e) # => false 4 | # Time.leap_year?(e) # => true 5 | -------------------------------------------------------------------------------- /Time/local.cr: -------------------------------------------------------------------------------- 1 | pp Time.new(2016, 1, 2).local? 2 | pp Time.new(2016, 1, 2).to_local.local? 3 | 4 | # (Time.new(2016, 1, 2)).local? # => false 5 | # (Time.new(2016, 1, 2)).to_local.local? # => true 6 | -------------------------------------------------------------------------------- /Time/local_offset_in_minutes.cr: -------------------------------------------------------------------------------- 1 | pp Time.local_offset_in_minutes 2 | 3 | # Time.local_offset_in_minutes # => 0 4 | -------------------------------------------------------------------------------- /Time/millisecond.cr: -------------------------------------------------------------------------------- 1 | (6..8).each {|e| 2 | time = Time.new(2016, 1, 2, 3, 4, 5, e) 3 | pp time.to_s("%Y/%m/%d-%H:%M:%S.%L") 4 | pp time.millisecond 5 | } 6 | 7 | # time.to_s("%Y/%m/%d-%H:%M:%S.%L") # => "2016/01/02-03:04:05.006" 8 | # time.millisecond # => 6 9 | # time.to_s("%Y/%m/%d-%H:%M:%S.%L") # => "2016/01/02-03:04:05.007" 10 | # time.millisecond # => 7 11 | # time.to_s("%Y/%m/%d-%H:%M:%S.%L") # => "2016/01/02-03:04:05.008" 12 | # time.millisecond # => 8 13 | -------------------------------------------------------------------------------- /Time/minus.cr: -------------------------------------------------------------------------------- 1 | pp Time.now - Time::MonthSpan.new(1) 2 | pp Time.now - Time::Span.new(100_000_000) 3 | pp Time.now 4 | 5 | # Time.now - (Time::MonthSpan.new(1)) # => 2016-09-14 13:01:57 +0000 6 | # Time.now - (Time::Span.new(100000000)) # => 2016-10-14 13:01:47 +0000 7 | # Time.now # => 2016-10-14 13:01:57 +0000 8 | -------------------------------------------------------------------------------- /Time/minute.cr: -------------------------------------------------------------------------------- 1 | (6..8).each {|e| 2 | time = Time.new(2016, 1, 2, 3, e, 5) 3 | pp time.to_s("%Y/%m/%d-%H:%M:%S.%L") 4 | pp time.minute 5 | } 6 | 7 | # time.to_s("%Y/%m/%d-%H:%M:%S.%L") # => "2016/01/02-03:06:05.000" 8 | # time.minute # => 6 9 | # time.to_s("%Y/%m/%d-%H:%M:%S.%L") # => "2016/01/02-03:07:05.000" 10 | # time.minute # => 7 11 | # time.to_s("%Y/%m/%d-%H:%M:%S.%L") # => "2016/01/02-03:08:05.000" 12 | # time.minute # => 8 13 | -------------------------------------------------------------------------------- /Time/monday.cr: -------------------------------------------------------------------------------- 1 | (1..7).each {|e| 2 | pp e 3 | pp Time.new(2016, 1, e, 3, 4, 5).monday? 4 | } 5 | 6 | 7 | # e # => 1 8 | # (Time.new(2016, 1, e, 3, 4, 5)).monday? # => false 9 | # e # => 2 10 | # (Time.new(2016, 1, e, 3, 4, 5)).monday? # => false 11 | # e # => 3 12 | # (Time.new(2016, 1, e, 3, 4, 5)).monday? # => false 13 | # e # => 4 14 | # (Time.new(2016, 1, e, 3, 4, 5)).monday? # => true 15 | # e # => 5 16 | # (Time.new(2016, 1, e, 3, 4, 5)).monday? # => false 17 | # e # => 6 18 | # (Time.new(2016, 1, e, 3, 4, 5)).monday? # => false 19 | # e # => 7 20 | # (Time.new(2016, 1, e, 3, 4, 5)).monday? # => false -------------------------------------------------------------------------------- /Time/month.cr: -------------------------------------------------------------------------------- 1 | (6..8).each {|e| 2 | time = Time.new(2016, e, 2) 3 | pp time.to_s("%Y/%m/%d") 4 | pp time.month 5 | } 6 | 7 | # time.to_s("%Y/%m/%d") # => "2016/06/02" 8 | # time.month # => 6 9 | # time.to_s("%Y/%m/%d") # => "2016/07/02" 10 | # time.month # => 7 11 | # time.to_s("%Y/%m/%d") # => "2016/08/02" 12 | # time.month # => 8 13 | -------------------------------------------------------------------------------- /Time/now.cr: -------------------------------------------------------------------------------- 1 | pp Time.now 2 | 3 | # Time.now # => 2016-10-10 16:38:48 +0000 4 | -------------------------------------------------------------------------------- /Time/parse.cr: -------------------------------------------------------------------------------- 1 | pp Time.parse("2016-10-09", "%F") 2 | pp Time.parse("10/09/16", "%x") 3 | pp Time.parse("16", "%y") 4 | pp Time.parse("2016", "%Y") 5 | 6 | # Time.parse("2016-10-09", "%F") # => 2016-10-09 00:00:00 7 | # Time.parse("10/09/16", "%x") # => 2016-10-09 00:00:00 8 | # Time.parse("16", "%y") # => 2016-01-01 00:00:00 9 | # Time.parse("2016", "%Y") # => 2016-01-01 00:00:00 10 | -------------------------------------------------------------------------------- /Time/plus.cr: -------------------------------------------------------------------------------- 1 | pp Time.now + Time::MonthSpan.new(1) 2 | pp Time.now + Time::Span.new(100_000_000) 3 | pp Time.now 4 | 5 | # Time.now + (Time::MonthSpan.new(1)) # => 2016-11-12 16:18:57 +0000 6 | # Time.now + (Time::Span.new(100000000)) # => 2016-10-12 16:19:07 +0000 7 | # Time.now # => 2016-10-12 16:18:57 +0000 -------------------------------------------------------------------------------- /Time/saturday.cr: -------------------------------------------------------------------------------- 1 | (1..7).each {|e| 2 | pp e 3 | pp Time.new(2016, 1, e, 3, 4, 5).saturday? 4 | } 5 | 6 | 7 | # e # => 1 8 | # (Time.new(2016, 1, e, 3, 4, 5)).saturday? # => false 9 | # e # => 2 10 | # (Time.new(2016, 1, e, 3, 4, 5)).saturday? # => true 11 | # e # => 3 12 | # (Time.new(2016, 1, e, 3, 4, 5)).saturday? # => false 13 | # e # => 4 14 | # (Time.new(2016, 1, e, 3, 4, 5)).saturday? # => false 15 | # e # => 5 16 | # (Time.new(2016, 1, e, 3, 4, 5)).saturday? # => false 17 | # e # => 6 18 | # (Time.new(2016, 1, e, 3, 4, 5)).saturday? # => false 19 | # e # => 7 20 | # (Time.new(2016, 1, e, 3, 4, 5)).saturday? # => false 21 | -------------------------------------------------------------------------------- /Time/second.cr: -------------------------------------------------------------------------------- 1 | (6..8).each {|e| 2 | time = Time.new(2016, 1, 2, 3, 4, e) 3 | pp time.to_s("%Y/%m/%d-%H:%M:%S.%L") 4 | pp time.second 5 | } 6 | 7 | # time.to_s("%Y/%m/%d-%H:%M:%S.%L") # => "2016/01/02-03:04:06.000" 8 | # time.second # => 6 9 | # time.to_s("%Y/%m/%d-%H:%M:%S.%L") # => "2016/01/02-03:04:07.000" 10 | # time.second # => 7 11 | # time.to_s("%Y/%m/%d-%H:%M:%S.%L") # => "2016/01/02-03:04:08.000" 12 | # time.second # => 8 13 | -------------------------------------------------------------------------------- /Time/sunday.cr: -------------------------------------------------------------------------------- 1 | (1..7).each {|e| 2 | pp e 3 | pp Time.new(2016, 1, e, 3, 4, 5).sunday? 4 | } 5 | 6 | # e # => 1 7 | # (Time.new(2016, 1, e, 3, 4, 5)).sunday? # => false 8 | # e # => 2 9 | # (Time.new(2016, 1, e, 3, 4, 5)).sunday? # => false 10 | # e # => 3 11 | # (Time.new(2016, 1, e, 3, 4, 5)).sunday? # => true 12 | # e # => 4 13 | # (Time.new(2016, 1, e, 3, 4, 5)).sunday? # => false 14 | # e # => 5 15 | # (Time.new(2016, 1, e, 3, 4, 5)).sunday? # => false 16 | # e # => 6 17 | # (Time.new(2016, 1, e, 3, 4, 5)).sunday? # => false 18 | # e # => 7 19 | # (Time.new(2016, 1, e, 3, 4, 5)).sunday? # => false 20 | -------------------------------------------------------------------------------- /Time/thursday.cr: -------------------------------------------------------------------------------- 1 | (1..7).each {|e| 2 | pp e 3 | pp Time.new(2016, 1, e, 3, 4, 5).thursday? 4 | } 5 | 6 | # e # => 1 7 | # (Time.new(2016, 1, e, 3, 4, 5)).thursday? # => false 8 | # e # => 2 9 | # (Time.new(2016, 1, e, 3, 4, 5)).thursday? # => false 10 | # e # => 3 11 | # (Time.new(2016, 1, e, 3, 4, 5)).thursday? # => false 12 | # e # => 4 13 | # (Time.new(2016, 1, e, 3, 4, 5)).thursday? # => false 14 | # e # => 5 15 | # (Time.new(2016, 1, e, 3, 4, 5)).thursday? # => false 16 | # e # => 6 17 | # (Time.new(2016, 1, e, 3, 4, 5)).thursday? # => false 18 | # e # => 7 19 | # (Time.new(2016, 1, e, 3, 4, 5)).thursday? # => true 20 | -------------------------------------------------------------------------------- /Time/to_utc.cr: -------------------------------------------------------------------------------- 1 | pp Time.new(2016, 1, 2).utc? 2 | pp Time.new(2016, 1, 2).to_utc 3 | pp Time.new(2016, 1, 2).to_utc.utc? 4 | 5 | # Time.new(2016, 1, 2)).utc? # => false 6 | # (Time.new(2016, 1, 2)).to_utc # => 2016-01-02 00:00:00 UTC 7 | # (Time.new(2016, 1, 2)).to_utc.utc? # => true 8 | -------------------------------------------------------------------------------- /Time/tuesday.cr: -------------------------------------------------------------------------------- 1 | (1..7).each {|e| 2 | pp e 3 | pp Time.new(2016, 1, e, 3, 4, 5).tuesday? 4 | } 5 | 6 | # e # => 1 7 | # (Time.new(2016, 1, e, 3, 4, 5)).tuesday? # => false 8 | # e # => 2 9 | # (Time.new(2016, 1, e, 3, 4, 5)).tuesday? # => false 10 | # e # => 3 11 | # (Time.new(2016, 1, e, 3, 4, 5)).tuesday? # => false 12 | # e # => 4 13 | # (Time.new(2016, 1, e, 3, 4, 5)).tuesday? # => false 14 | # e # => 5 15 | # (Time.new(2016, 1, e, 3, 4, 5)).tuesday? # => true 16 | # e # => 6 17 | # (Time.new(2016, 1, e, 3, 4, 5)).tuesday? # => false 18 | # e # => 7 19 | # (Time.new(2016, 1, e, 3, 4, 5)).tuesday? # => false 20 | -------------------------------------------------------------------------------- /Time/utc.cr: -------------------------------------------------------------------------------- 1 | pp Time.new(2016, 1, 2).utc? 2 | pp Time.new(2016, 1, 2).to_utc.utc? 3 | 4 | # (Time.new(2016, 1, 2)).utc? # => false 5 | # (Time.new(2016, 1, 2)).to_utc.utc? # => true 6 | -------------------------------------------------------------------------------- /Time/utc_now.cr: -------------------------------------------------------------------------------- 1 | pp Time.now 2 | pp Time.utc_now 3 | 4 | # Time.now # => 2016-10-12 09:43:45 +0900 5 | # Time.utc_now # => 2016-10-12 00:43:45 UTC 6 | -------------------------------------------------------------------------------- /Time/wednesday.cr: -------------------------------------------------------------------------------- 1 | (1..7).each {|e| 2 | pp e 3 | pp Time.new(2016, 1, e, 3, 4, 5).wednesday? 4 | } 5 | 6 | #e # => 1 7 | # (Time.new(2016, 1, e, 3, 4, 5)).wednesday? # => false 8 | # e # => 2 9 | # (Time.new(2016, 1, e, 3, 4, 5)).wednesday? # => false 10 | # e # => 3 11 | # (Time.new(2016, 1, e, 3, 4, 5)).wednesday? # => false 12 | # e # => 4 13 | # (Time.new(2016, 1, e, 3, 4, 5)).wednesday? # => false 14 | # e # => 5 15 | # (Time.new(2016, 1, e, 3, 4, 5)).wednesday? # => false 16 | # e # => 6 17 | # (Time.new(2016, 1, e, 3, 4, 5)).wednesday? # => true 18 | # e # => 7 19 | # (Time.new(2016, 1, e, 3, 4, 5)).wednesday? # => false 20 | -------------------------------------------------------------------------------- /Time/year.cr: -------------------------------------------------------------------------------- 1 | (2000..2005).each {|e| 2 | pp e 3 | pp Time.new(e, 1, 2).year 4 | } 5 | 6 | # e # => 2000 7 | # (Time.new(e, 1, 2)).year # => 2000 8 | # e # => 2001 9 | # (Time.new(e, 1, 2)).year # => 2001 10 | # e # => 2002 11 | # (Time.new(e, 1, 2)).year # => 2002 12 | # e # => 2003 13 | # (Time.new(e, 1, 2)).year # => 2003 14 | # e # => 2004 15 | # (Time.new(e, 1, 2)).year # => 2004 16 | # e # => 2005 17 | # (Time.new(e, 1, 2)).year # => 2005 18 | -------------------------------------------------------------------------------- /Tuple/at.cr: -------------------------------------------------------------------------------- 1 | pp ({"hoge", "hige", "hage"}).at(0) 2 | pp ({"hoge", "hige", "hage"}).at(1) 3 | pp ({"hoge", "hige", "hage"}).at(2) { "no data" } 4 | pp ({"hoge", "hige", "hage"}).at(5) { "no data" } 5 | 6 | # ({"hoge", "hige", "hage"}).at(0) # => "hoge" 7 | # ({"hoge", "hige", "hage"}).at(1) # => "hige" 8 | # ({"hoge", "hige", "hage"}).at(2) do 9 | # "no data" 10 | # end # => "hage" 11 | # ({"hoge", "hige", "hage"}).at(5) do 12 | # "no data" 13 | # end # => "no data" 14 | -------------------------------------------------------------------------------- /Tuple/compare.cr: -------------------------------------------------------------------------------- 1 | pp ({1, 2, 3} <=> {1, 2, 3}) 2 | pp ({1, 2, 3} <=> {1, 2}) 3 | pp ({1, 1, 3} <=> {1, 2, 3}) 4 | 5 | # ({1, 2, 3}) <=> ({1, 2, 3}) # => 0 6 | # ({1, 2, 3}) <=> ({1, 2}) # => 1 7 | # ({1, 1, 3}) <=> ({1, 2, 3}) # => -1 8 | -------------------------------------------------------------------------------- /Tuple/each.cr: -------------------------------------------------------------------------------- 1 | {1, "two", :hoge}.each {|e|pp "value=#{e}"} 2 | 3 | # "value=#{e}" # => "value=1" 4 | # "value=#{e}" # => "value=two" 5 | # "value=#{e}" # => "value=hoge" 6 | -------------------------------------------------------------------------------- /Tuple/eq.cr: -------------------------------------------------------------------------------- 1 | pp ({ 1, 2 } == { 1, 2 }) 2 | pp ({ 1, 2 } == { 2, 2 }) 3 | 4 | # ({1, 2}) == ({1, 2}) # => true 5 | # ({1, 2}) == ({2, 2}) # => false -------------------------------------------------------------------------------- /Tuple/eqq.cr: -------------------------------------------------------------------------------- 1 | class Person 2 | property name : String 3 | property age : Int32 4 | def initialize(@name, @age) 5 | end 6 | 7 | def ==(other) 8 | return true if name == other.name && age == other.age 9 | false 10 | end 11 | 12 | def ===(other) 13 | !!(self.hash === other.hash) 14 | end 15 | end 16 | 17 | tanaka1 = Person.new("tanaka", 32) 18 | tanaka2 = Person.new("tanaka", 32) 19 | 20 | pp ({ 1, tanaka1 } == { 1, tanaka2 }) 21 | pp ({ 1, tanaka1 } === { 1, tanaka2 }) 22 | pp ({ 1, 2 } === { 1, 2 }) 23 | 24 | # ({1, tanaka1}) == ({1, tanaka2}) # => true 25 | # ({1, tanaka1}) === ({1, tanaka2}) # => false 26 | # ({1, 2}) === ({1, 2}) # => true 27 | -------------------------------------------------------------------------------- /Tuple/first.cr: -------------------------------------------------------------------------------- 1 | pp ({ 1, "value" }).first 2 | 3 | # ({1, "value"}).first # => 1 4 | -------------------------------------------------------------------------------- /Tuple/first_q.cr: -------------------------------------------------------------------------------- 1 | pp ({ 1, "value" }).first 2 | pp ({ 1, "value" }).first? 3 | pp (Tuple.new).first? 4 | 5 | # ({1, "value"}).first # => 1 6 | # ({1, "value"}).first? # => 1 7 | # Tuple.new.first? # => nil 8 | -------------------------------------------------------------------------------- /Tuple/from.cr: -------------------------------------------------------------------------------- 1 | require "json" 2 | 3 | data = JSON.parse(%(["int key", 99])).as_a 4 | pp ({String, Int64}).from(data) 5 | pp ({String, Int64}).from(data).class 6 | 7 | # ({String, Int64}).from(data) # => {"int key", 99} 8 | # (({String, Int64}).from(data)).class # => Tuple(String, Int64) 9 | -------------------------------------------------------------------------------- /Tuple/hash.cr: -------------------------------------------------------------------------------- 1 | pp ({ "string", 1 }).hash 2 | pp ({ "string", 1 }).hash 3 | pp ({ "string", 2 }).hash 4 | 5 | # ({"string", 1}).hash # => -1881699634 6 | # ({"string", 1}).hash # => -1881699634 7 | # ({"string", 2}).hash # => -1881699633 8 | -------------------------------------------------------------------------------- /Tuple/inspect.cr: -------------------------------------------------------------------------------- 1 | require "json" 2 | 3 | pp ({"string", 1}).inspect 4 | pp ({"string", :symbol}).inspect 5 | 6 | # ({"string", 1}).inspect # => "{\"string\", 1}" 7 | # ({"string", :symbol}).inspect # => "{\"string\", :symbol}" 8 | -------------------------------------------------------------------------------- /Tuple/last.cr: -------------------------------------------------------------------------------- 1 | require "json" 2 | 3 | data = JSON.parse(%(["int key", 99])).as_a 4 | pp ({String, Int64}).from(data) 5 | pp ({String, Int64}).from(data).class 6 | 7 | # ({String, Int64}).from(data) # => {"int key", 99} 8 | # (({String, Int64}).from(data)).class # => Tuple(String, Int64) 9 | -------------------------------------------------------------------------------- /Tuple/map.cr: -------------------------------------------------------------------------------- 1 | require "json" 2 | 3 | pp ({"a", 1}).map(&.succ) 4 | pp ({"a", 1}).map{|e|e * 2} 5 | 6 | # ({"a", 1}).map(&.succ) # => {"b", 2} 7 | # ({"a", 1}).map(&.*(2)) # => {"aa", 2} 8 | -------------------------------------------------------------------------------- /Tuple/new.cr: -------------------------------------------------------------------------------- 1 | Tuple(String, String).from(["key", "value"]) # => {"key", "value"} 2 | Tuple(String, String).from(["key", "value"]).class # => {String, String} 3 | Tuple(String, Int64).from(["int key", 99]) # => {"int key", 99} 4 | Tuple(String, Int64).from(["int key", 99]).class # => {String, Int64} 5 | -------------------------------------------------------------------------------- /Tuple/plus.cr: -------------------------------------------------------------------------------- 1 | num = { 1, 2 } 2 | string = { "test1", "test2" } 3 | pp num + string 4 | pp (num + string).class 5 | 6 | # num + string # => {1, 2, "test1", "test2"} 7 | # (num + string).class # => Tuple(Int32, Int32, String, String) 8 | -------------------------------------------------------------------------------- /Tuple/reverse.cr: -------------------------------------------------------------------------------- 1 | pp (["key", "value", 1, 2]) 2 | pp (["key", "value", 1, 2]).reverse 3 | 4 | # ["key", "value", 1, 2] # => ["key", "value", 1, 2] 5 | # ["key", "value", 1, 2].reverse # => [2, 1, "value", "key"] 6 | -------------------------------------------------------------------------------- /Tuple/reverse_each.cr: -------------------------------------------------------------------------------- 1 | (["key", "value", 1, 2]).reverse_each {|e|pp e} 2 | 3 | # "key", "value", 1, 2].reverse_each do |e| 4 | # pp(e) 5 | # end # => e # => 2 6 | # e # => 1 7 | # e # => "value" 8 | # e # => "key" 9 | -------------------------------------------------------------------------------- /Tuple/size.cr: -------------------------------------------------------------------------------- 1 | pp (["key", "value", 1, 2]).size 2 | pp (["key", "value", 1, 2, 3]).size 3 | 4 | # ["key", "value", 1, 2].size # => 4 5 | # ["key", "value", 1, 2, 3].size # => 5 6 | -------------------------------------------------------------------------------- /Tuple/square_bracket.cr: -------------------------------------------------------------------------------- 1 | t = { 1, 2 } 2 | pp t[0]? 3 | pp t[2]? 4 | 5 | # t[0]? # => 1 6 | # t[2]? # => nil 7 | -------------------------------------------------------------------------------- /URI/eq.cr: -------------------------------------------------------------------------------- 1 | require "uri" 2 | uri1 = URI.parse("https://crystal-lang.org/api/0.19.4/URI.html#parse%28raw_url%3AString%29%3AURI-class-method") 3 | uri2 = URI.parse("https://crystal-lang.org/api/0.19.4/URI.html#parse%28raw_url%3AString%29%3AURI-class-method") 4 | uri3 = URI.parse("https://crystal-lang.org/api/0.19.4/") 5 | 6 | pp uri1 == uri1 7 | pp uri1 == uri2 8 | pp uri1 == uri3 9 | 10 | # uri1 == uri1 # => true 11 | # uri1 == uri2 # => true 12 | # uri1 == uri3 # => false 13 | -------------------------------------------------------------------------------- /URI/escape.cr: -------------------------------------------------------------------------------- 1 | require "uri" 2 | pp URI.escape("https://example.com/q?=hogehoge test") 3 | 4 | # URI.escape("https://example.com/q?=hogehoge test") # => "https%3A%2F%2Fexample.com%2Fq%3F%3Dhogehoge%20test" 5 | -------------------------------------------------------------------------------- /URI/fragment.cr: -------------------------------------------------------------------------------- 1 | require "uri" 2 | pp URI.parse("http://example.com/emoji#font_awesome").fragment 3 | pp URI.parse("http://example.com/emoji#decomoji?q=hoge").fragment 4 | 5 | # (URI.parse("http://example.com/emoji#font_awesome")).fragment # => "font_awesome" 6 | # (URI.parse("http://example.com/emoji#decomoji?q=hoge")).fragment # => "decomoji?q=hoge" 7 | -------------------------------------------------------------------------------- /URI/full_path.cr: -------------------------------------------------------------------------------- 1 | require "uri" 2 | uri = URI.new(scheme = "https", host = "example.com", port = 3000, path = "/users", query = "q=tanaka", user = "sato", password = "sato9999") 3 | pp uri.full_path 4 | 5 | # uri.full_path # => "/users?q=tanaka" 6 | -------------------------------------------------------------------------------- /URI/hash.cr: -------------------------------------------------------------------------------- 1 | require "uri" 2 | pp URI.parse("http://example.com/emoji").hash 3 | pp URI.parse("http://example.com/emoji").hash 4 | pp URI.parse("http://example.com/emoji?q=hoge").hash 5 | 6 | # (URI.parse("http://example.com/emoji")).hash # => -208572460 7 | # (URI.parse("http://example.com/emoji")).hash # => -208572460 8 | # (URI.parse("http://example.com/emoji?q=hoge")).hash # => -185914523 -------------------------------------------------------------------------------- /URI/host.cr: -------------------------------------------------------------------------------- 1 | require "uri" 2 | pp URI.parse("http://example.com/emoji").host 3 | pp URI.parse("http://github.com/tbpgr").host 4 | 5 | # (URI.parse("http://example.com/emoji")).host # => "example.com" 6 | # (URI.parse("http://github.com/tbpgr")).host # => "github.com" 7 | -------------------------------------------------------------------------------- /URI/new.cr: -------------------------------------------------------------------------------- 1 | require "uri" 2 | uri = URI.new(scheme = "https", host = "example.com", port = 3000, path = "/users", query = "q=tanaka", user = "sato", password = "sato9999") 3 | pp uri 4 | pp uri.to_s 5 | 6 | # uri # => # 7 | # uri.to_s # => "https://sato:sato9999@example.com:3000/users?q=tanaka" 8 | -------------------------------------------------------------------------------- /URI/opaque.cr: -------------------------------------------------------------------------------- 1 | require "uri" 2 | pp URI.parse("http://example.com/emoji").opaque 3 | pp URI.parse("mailto:sample@example.com").opaque 4 | 5 | # (URI.parse("http://example.com/emoji")).opaque # => nil 6 | # (URI.parse("mailto:sample@example.com")).opaque # => "sample@example.com" 7 | -------------------------------------------------------------------------------- /URI/parse.cr: -------------------------------------------------------------------------------- 1 | require "uri" 2 | uri = URI.parse("https://crystal-lang.org/api/0.19.4/URI.html#parse%28raw_url%3AString%29%3AURI-class-method") 3 | pp uri 4 | pp uri.to_s 5 | 6 | # uri # => # 16 | # uri.to_s # => "https://crystal-lang.org/api/0.19.4/URI.html#parse%28raw_url%3AString%29%3AURI-class-method" 17 | -------------------------------------------------------------------------------- /URI/password.cr: -------------------------------------------------------------------------------- 1 | require "uri" 2 | uri = URI.new(scheme = "https", host = "example.com", port = 3000, path = "/users", query = "q=tanaka", user = "sato", password = "sato9999") 3 | pp uri 4 | pp uri.password 5 | 6 | # uri # => # 16 | # uri.password # => "sato9999" -------------------------------------------------------------------------------- /URI/path.cr: -------------------------------------------------------------------------------- 1 | require "uri" 2 | uri = URI.new(scheme = "https", host = "example.com", port = 3000, path = "/users", query = "q=tanaka", user = "sato", password = "sato9999") 3 | pp uri 4 | pp uri.path 5 | 6 | # uri # => # 16 | # uri.path # => "/users" -------------------------------------------------------------------------------- /URI/port.cr: -------------------------------------------------------------------------------- 1 | require "uri" 2 | uri = URI.new(scheme = "https", host = "example.com", port = 3000, path = "/users", query = "q=tanaka", user = "sato", password = "sato9999") 3 | pp uri 4 | pp uri.port 5 | 6 | # uri # => # 16 | # uri.port # => 3000 17 | -------------------------------------------------------------------------------- /URI/query.cr: -------------------------------------------------------------------------------- 1 | require "uri" 2 | uri = URI.new(scheme = "https", host = "example.com", port = 3000, path = "/users", query = "q=tanaka", user = "sato", password = "sato9999") 3 | pp uri 4 | pp uri.query 5 | 6 | # uri # => # 7 | # uri.query # => "q=tanaka" 8 | -------------------------------------------------------------------------------- /URI/query_eq.cr: -------------------------------------------------------------------------------- 1 | require "uri" 2 | uri = URI.new(scheme = "https", host = "example.com", port = 3000, path = "/users", query = "q=tanaka", user = "sato", password = "sato9999") 3 | pp uri 4 | pp uri.query 5 | pp uri.query = "updated" 6 | pp uri 7 | pp uri.query 8 | 9 | # uri # => # 10 | # uri.query # => "q=tanaka" 11 | # uri.query = "updated" # => "updated" 12 | # uri # => # 13 | # uri.query # => "updated" 14 | -------------------------------------------------------------------------------- /URI/reserved.cr: -------------------------------------------------------------------------------- 1 | require "uri" 2 | pp URI.reserved?(':'.ord.to_u8) 3 | pp URI.reserved?('/'.ord.to_u8) 4 | pp URI.reserved?(' '.ord.to_u8) 5 | 6 | # URI.reserved?(':'.ord.to_u8) # => true 7 | # URI.reserved?('/'.ord.to_u8) # => true 8 | # URI.reserved?(' '.ord.to_u8) # => false 9 | -------------------------------------------------------------------------------- /URI/scheme.cr: -------------------------------------------------------------------------------- 1 | require "uri" 2 | uri = URI.new(scheme = "https", host = "example.com", port = 3000, path = "/users", query = "q=tanaka", user = "sato", password = "sato9999") 3 | pp uri 4 | pp uri.scheme 5 | 6 | # uri # => # 16 | # uri.scheme # => "https" 17 | -------------------------------------------------------------------------------- /URI/to_s.cr: -------------------------------------------------------------------------------- 1 | require "uri" 2 | uri = URI.new(scheme = "https", host = "example.com", port = 3000, path = "/users", query = "q=tanaka", user = "sato", password = "sato9999") 3 | pp uri 4 | pp uri.to_s 5 | 6 | # uri # => # 16 | # uri.to_s # => "https://sato:sato9999@example.com:3000/users?q=tanaka" -------------------------------------------------------------------------------- /URI/unescape.cr: -------------------------------------------------------------------------------- 1 | require "uri" 2 | escaped = URI.escape("https://example.com/q?=hogehoge test") 3 | pp escaped 4 | pp URI.unescape(escaped) 5 | 6 | # escaped # => "https%3A%2F%2Fexample.com%2Fq%3F%3Dhogehoge%20test" 7 | # URI.unescape(escaped) # => "https://example.com/q?=hogehoge test" 8 | -------------------------------------------------------------------------------- /URI/unreserved.cr: -------------------------------------------------------------------------------- 1 | require "uri" 2 | pp URI.unreserved?('9'.ord.to_u8) 3 | pp URI.unreserved?('_'.ord.to_u8) 4 | pp URI.unreserved?(' '.ord.to_u8) 5 | 6 | # URI.unreserved?('9'.ord.to_u8) # => true 7 | # URI.unreserved?('_'.ord.to_u8) # => true 8 | # URI.unreserved?(' '.ord.to_u8) # => false 9 | -------------------------------------------------------------------------------- /URI/user.cr: -------------------------------------------------------------------------------- 1 | require "uri" 2 | uri = URI.new(scheme = "https", host = "example.com", port = 3000, path = "/users", query = "q=tanaka", user = "sato", password = "sato9999") 3 | pp uri 4 | pp uri.user 5 | 6 | # uri # => # 7 | # uri.user # => "sato" 8 | -------------------------------------------------------------------------------- /URI/user_eq.cr: -------------------------------------------------------------------------------- 1 | require "uri" 2 | uri = URI.new(scheme = "https", host = "example.com", port = 3000, path = "/users", query = "q=tanaka", user = "sato", password = "sato9999") 3 | pp uri 4 | pp uri.user 5 | pp uri.user = "updated" 6 | pp uri 7 | pp uri.user 8 | 9 | # uri # => # 10 | # uri.user # => "sato" 11 | # uri.user = "updated" # => "updated" 12 | # uri # => # 13 | # uri.user # => "updated" 14 | -------------------------------------------------------------------------------- /URI/userinfo.cr: -------------------------------------------------------------------------------- 1 | require "uri" 2 | uri = URI.new(scheme = "https", host = "example.com", port = 3000, path = "/users", query = "q=tanaka", user = "sato", password = "sato9999") 3 | pp uri 4 | pp uri.userinfo 5 | 6 | # uri # => # 7 | # uri.userinfo # => "sato:sato9999" 8 | -------------------------------------------------------------------------------- /Union/new.cr: -------------------------------------------------------------------------------- 1 | pp Union(String | Int32) 2 | pp Union(String | Nil | Array(String)) 3 | 4 | # Union(String | Int32) # => (Int32 | String) 5 | # Union(String | Nil | Array(String)) # => (Array(String) | String | Nil) 6 | -------------------------------------------------------------------------------- /Union/nilable.cr: -------------------------------------------------------------------------------- 1 | pp Union(String | Int32).nilable? 2 | pp Union(String | Nil | Array(String)).nilable? 3 | 4 | # Union(String | Int32).nilable? # => false 5 | # Union(String | Nil | Array(String)).nilable? # => true 6 | -------------------------------------------------------------------------------- /XML/escape.cr: -------------------------------------------------------------------------------- 1 | require "xml" 2 | 3 | pp XML.escape("beforeafter") 4 | 5 | # XML.escape("beforeafter") # => "before<tag>after" 6 | -------------------------------------------------------------------------------- /XML/parse.cr: -------------------------------------------------------------------------------- 1 | require "xml" 2 | 3 | xml = XML.parse("hige contents") 4 | pp xml 5 | pp xml.to_s 6 | 7 | # xml # => #]>]>]> 8 | # xml.to_s # => "\n\n hige contents\n\n" 9 | -------------------------------------------------------------------------------- /XML/parse_html.cr: -------------------------------------------------------------------------------- 1 | require "xml" 2 | 3 | xml = XML.parse_html(" Document ") 4 | pp xml.to_s 5 | 6 | # xml.to_s # => "\n\n Document \n" 7 | -------------------------------------------------------------------------------- /toplevels/pp.cr: -------------------------------------------------------------------------------- 1 | ary = [1, 2, 3] 2 | pp [ 3 | 1, 4 | "hoge", 5 | ary, 6 | ary+ary, 7 | { key1: :value1, key2: :value2 } 8 | ] 9 | 10 | # --------------------------------------------------------------------------------