Introducing Crystal Programming Language

struct User
  def initialize(@name : String, @age : Int32)
  end

  # 同値性比較のメソッドを定義
  def ==(other : self)
    return false unless @name == other.@name
    return false unless @age == other.@age
    true
  end
end

user1 = User.new "Taro", 30
user2 = User.new "Taro", 30
user1 == user2 # => true

struct User
  def initialize(@name : String, @age : Int32)
  end

  # 同値性比較のメソッドを定義
  def_equals @name, @age
end

user1 = User.new "Taro", 30
user2 = User.new "Taro", 30
user1 == user2 # => true

# Structの定義
struct User
  property name : String
  property age : Int32

  def initialize(@name, @age)
  end
end

user1 = User.new "Taro", 30
user1      # => User(@name="Taro", @age=30)
user1.name # => "Taro"
user1.age  # => 30

# Structの定義
record User, name : String, age : Int32

user1 = User.new "Taro", 30
user1      # => User(@name="Taro", @age=30)
user1.name # => "Taro"
user1.age  # => 30

macro my_macro(method_name, content)
  def {{method_name}} (1)
    {{content}}
  end
end

my_macro my_method, "hoge" (2)
my_method # => "hoge"

# 引数のclass_nameを表示させるmacro
macro ast_node_class_name(ast_node)
  {{ ast_node.class_name }}
end

ast_node_class_name(1)              # => "NumberLiteral"
ast_node_class_name("string")       # => "StringLiteral"
ast_node_class_name(ast)            # => "Call"
ast_node_class_name(["a", "b"])     # => "ArrayLiteral"
ast_node_class_name({key: "value"}) # => "NamedTupleLiteral"

macro ast_node_line_number(ast_node)
  {{ ast_node.line_number }}
end

# ... 他のコードが並ぶ

ast_node_line_number 1        # => 12
ast_node_line_number "string" # => 13

macro ast_node_stringify(ast_node)
  {{ ast_node.stringify }}
end

ast_node_stringify 1          # => "1"
ast_node_stringify "string"   # => "\"string\""
ast_node_stringify ["a", "b"] # => "[\"a\", \"b\"]"
ast_node_stringify CONST      # => "CONST"

macro ast_node_array_literal(ast_node)
  {{ ast_node.map(&.capitalize).join("::") }}
end

ast_node_array_literal ["apple", "banana"] # => "Apple::Banana"

# トップレベルで定義されたマクロは、どこからでも参照可能
macro my_macro
  "expanded my macro!!!"
end

my_macro # => "expanded my macro!!!"

# private を付けた場合は、同一ファイル内でのみ参照可能
private macro my_macro
  "expanded my macro!!!"
end

my_macro # => "expanded my macro!!!"

class MacroScope
  macro my_macro
    "expanded my macro!!"
  end

  # class 内で参照可能
  CONSTANT = my_macro

  # インスタンスメソッド内で参照可能
  def instance_method
    my_macro
  end

  # クラスメソッド内で参照可能
  def self.class_method
    my_macro
  end
end

# クラスメソッドと同じ syntax で参照可能
MacroScope.my_macro # => "expanded my macro!!"

# インスタンスメソッドとしては参照できない
# MacroScope.new.my_macro は undefined method になる

MacroScope::CONSTANT           # => "expanded my macro!!"
MacroScope.new.instance_method # => "expanded my macro!!"
MacroScope.class_method        # => "expanded my macro!!"

macro conditionals(content)
  {% if content == 1 %}
    "one"
  {% else %}
    {{ content }}
  {% end %}
end

conditionals 1 # => "one"
conditionals 2 # => 2

{% if env("DEBUG") %}
  puts "===== DEBUG MODE ======"
{% end %}

macro iteration(names)
  {% for name, index in names %}
    def {{name}}
      {{index}}
    end
  {% end %}
end

iteration [foo, bar, baz]

foo # => 0
bar # => 1
baz # => 2

macro iteration(names)
  {% for key, value in names %}
    def {{key.id}}
      {{value}}
    end
  {% end %}
end

iteration({foo: "FOO", bar: "BAR", baz: "BAZ"})

foo # => "FOO"
bar # => "BAR"
baz # => "BAZ"

{% for name, index in ["foo", "bar", "baz"] %}
  def {{name.id}}
    {{index}}
  end
{% end %}

foo # => 0
bar # => 1
baz # => 2

macro variadic_arguments(*names)
  {% for name, index in names %}
    def {{name.id}}
      {{index}}
    end
  {% end %}
end

variadic_arguments foo, bar, baz

foo # => 0
bar # => 1
baz # => 2

macro splat
  p "Splatting a array"
  {% array = [1, 2, 3] %}
  p {{*array}}

  p "Splatting a tuple"
  {% tuple = {4, 5, 6} %}
  p {{*tuple}}

  # p "Double Splatting a hash"
  # {% hash = {"a" => 1, "b" => 2} %}
  # p {{**hash}}
  # ------------
  # Syntax error in expanded macro: splat:11: unexpected token: =>
  #
  # p "a" => 1, "b" => 2
  #       ^

  p "Double Splatting a named tuple"
  {% named_tuple = {"c": 3, "d": 4} %}
  p {{**named_tuple}}
end

splat
# output:
# "Splatting a array"
# 1
# 2
# 3
# "Splatting a tuple"
# 4
# 5
# 6
# "Double Splatting a named tuple"
# {c: 3, d: 4}

CONSTANTS = ["foo", "bar", "baz"]

{% for value in CONSTANTS %}
  puts {{value}}
{% end %}
# output:
# foo
# bar
# baz

ret = ""
var = "pitfalls"

ret = case var
  {% for klass in [Int32, String] %}
    when {{ klass.id }} then "#{var} is {{ klass }}"
  {% end %}
end

ret = ""

{% begin %}
  var = "pitfalls"

  ret = case var
    {% for klass in [Int32, String] %}
      when {{ klass.id }} then "#{var} is {{ klass }}"
    {% end %}
  end
{% end %}

ret # => "pitfalls is String"

class SuperClass
  macro inherited
    def type_name
      {{ @type.name.stringify }}
    end
  end
end

class SubClass < SuperClass
end

# SuperClass.new.type_name は undefined method 'type_name' for SuperClass となる
SubClass.new.type_name # => "SubClass"

macro method_missing(call)
  puts "name: {{call.name.id}}"
  puts "args: {{call.args.size}} arguments"
end

foo
# output:
# name: foo
# args: 0 arguments

bar 1, 'a'
# output:
# name: bar
# args: 2 arguments

macro update_x
  x = 1
end

x = 0
update_x

x # => 1

macro dont_update_x
  %x = 1
  puts %x
end

x = 0
dont_update_x # outputs 1

x # => 0

$ crystal tool expand -c /path/to/fresh_variables_example.cr:6:1 /path/to/fresh_variables_example.cr
1 expansion found
expansion 1:
   dont_update_x

# expand macro 'dont_update_x' (/path/to/fresh_variables_example.cr:2:1)
~> __temp_20 = 1
   puts(__temp_20)