trackler 2.1.0.0 → 2.1.0.1

data/tracks/ruby/lib/generator/exercise_cases.rb

@@ -0,0 +1,43 @@
+require 'ostruct'
+require 'json'
+
+class ExerciseCase < OpenStruct
+  using Generator::Underscore
+
+  def name
+    'test_%s' % description.underscore
+  end
+
+  def skipped
+    index.zero? ? '# skip' : 'skip'
+  end
+
+  protected
+
+  # used in workload, for example, as
+  #   "#{assert} Luhn.valid?(#{input.inspect})"
+  def assert
+    expected ? 'assert' : 'refute'
+  end
+
+  # used in workload, for example, as
+  #   assert_equal { "PigLatin.translate(#{input.inspect})" }
+  def assert_equal
+    "assert_equal #{expected.inspect}, #{yield}"
+  end
+
+  # used in workload, for example, as
+  #   if raises_error?
+  #     assert_raises(ArgumentError) { test_case }
+  #   else
+  #     assert_equal { test_case }
+  #   end
+
+  def raises_error?
+    expected.to_i == -1
+  end
+
+  def assert_raises(error)
+    "assert_raises(#{error}) { #{yield} }"
+  end
+end

data/tracks/ruby/lib/generator/underscore.rb

@@ -0,0 +1,9 @@
+module Generator
+  module Underscore
+    refine String do
+      def underscore
+        downcase.gsub(/[- ]/, '_').gsub(/[^\w?]/, '')
+      end
+    end
+  end
+end

data/tracks/ruby/lib/hamming_cases.rb

@@ -1,21 +1,16 @@
-require 'exercise_cases'
-
-class HammingCase < OpenStruct
-  def name
-    'test_%s' % description.gsub(/[ -]/, '_')
-  end
-
+class HammingCase < ExerciseCase
   def workload
-    "Hamming.compute('#{strand1}', '#{strand2}')"
+    if raises_error?
+      assert_raises(ArgumentError) { test_case }
+    else
+      assert_equal { test_case }
+    end
   end
 
-  def raises_error?
-    expected.to_i == -1
-  end
+  private
 
-  def skipped
-    index.zero? && '# skip' ||
-      'skip'
+  def test_case
+    "Hamming.compute('#{strand1}', '#{strand2}')"
   end
 end
 

data/tracks/ruby/lib/luhn_cases.rb

@@ -1,22 +1,6 @@
-require 'exercise_cases'
-
-class LuhnCase < OpenStruct
-  def name
-    'test_%s' % description.tr('- ', '__')
-  end
-
+class LuhnCase < ExerciseCase
   def workload
-    %Q(#{assertion} Luhn.valid?(#{input.inspect}))
-  end
-
-  def skipped
-    index.zero? ? '# skip' : 'skip'
-  end
-
-  private
-
-  def assertion
-    expected ? 'assert' : 'refute'
+    "#{assert} Luhn.valid?(#{input.inspect})"
   end
 end
 

data/tracks/ruby/lib/ocr_numbers_cases.rb

@@ -0,0 +1,20 @@
+class OcrNumbersCase < ExerciseCase
+  def workload
+    if raises_error?
+      assert_raises(ArgumentError) { test_case }
+    else
+      assert_equal { test_case }
+    end
+  end
+
+  private
+
+  def test_case
+    %Q(OcrNumbers.convert(#{(input.join("\n")).inspect}))
+  end
+end
+
+OcrNumbersCases = proc do |data|
+  JSON.parse(data)['cases'].flat_map {|section| section['cases'] }.
+    map.with_index {|test, index| OcrNumbersCase.new(test.merge('index' => index)) }
+end

data/tracks/ruby/lib/pig_latin_cases.rb

@@ -1,16 +1,6 @@
-require 'exercise_cases'
-
-class PigLatinCase < OpenStruct
-  def name
-    'test_%s' % description.tr('- ', '__')
-  end
-
+class PigLatinCase < ExerciseCase
   def workload
-    %Q(assert_equal #{expected.inspect}, PigLatin.translate(#{input.inspect}))
-  end
-
-  def skipped
-    index.zero? ? '# skip' : 'skip'
+    assert_equal { "PigLatin.translate(#{input.inspect})" }
   end
 end
 

data/tracks/ruby/test/generator/underscore_test.rb

@@ -0,0 +1,23 @@
+require_relative '../test_helper'
+
+module Generator
+  class UnderscoreTest < MiniTest::Test
+    using Underscore
+
+    # at present, we're downcasing everything, including TLAs
+    def test_mixed_case
+      assert_equal 'A string with TLA'.underscore, 'a_string_with_tla'
+    end
+
+    def test_hyphenated_text
+      assert_equal 'large distance in off-by-one strand'.underscore, 'large_distance_in_off_by_one_strand'
+    end
+
+    def test_question_mark
+      assert_equal(
+        'Unreadable but correctly sized inputs return ?'.underscore,
+        'unreadable_but_correctly_sized_inputs_return_?'
+      )
+    end
+  end
+end

data/tracks/scala/config.json

@@ -29,59 +29,94 @@
          ]
       },
       {
-         "slug":"run-length-encoding",
+         "slug":"leap",
          "difficulty":1,
          "topics":[
-            "Algorithms",
-            "Transforming",
-            "Strings"
+            "Integers",
+            "Mathematics"
          ]
       },
       {
-         "slug":"hamming",
-         "difficulty":2,
+         "slug":"space-age",
+         "difficulty":1,
          "topics":[
-            "Strings",
-            "Filtering",
-            "Optional values"
+            "Dates",
+            "Enumerations",
+            "Domain-specific languages"
          ]
-      },
+      },      
       {
-         "slug":"word-count",
+         "slug":"gigasecond",
          "difficulty":1,
          "topics":[
-            "Maps",
-            "Strings",
-            "Transforming"
+            "Dates",
+            "Time",
+            "Function Overloading"
          ]
       },
       {
-         "slug":"pangram",
+         "slug":"difference-of-squares",
          "difficulty":1,
+         "topics":[
+            "Integers",
+            "Mathematics"
+         ]
+      },  
+      {
+         "slug":"pangram",
+         "difficulty":2,
          "topics":[
             "Strings"
          ]
       },
       {
-         "slug":"anagram",
-         "difficulty":1,
+         "slug":"grade-school",
+         "difficulty":2,
          "topics":[
+            "Maps",
             "Sequences",
+            "Sorting"
+         ]
+      }, 
+      {
+         "slug":"accumulate",
+         "difficulty":2,
+         "topics":[
+            "Generics",
+            "Lists",
+            "Transforming"
+         ]
+      }, 
+      {
+         "slug":"raindrops",
+         "difficulty":2,
+         "topics":[
             "Strings",
-            "Filtering"
+            "Logic",
+            "Transforming"
          ]
       },
       {
-         "slug":"nucleotide-count",
-         "difficulty":1,
+         "slug":"perfect-numbers",
+         "difficulty":2,
          "topics":[
-            "Maps",
-            "Strings"
+            "Enumerations",
+            "Integers",
+            "Mathematics"
+         ]
+      },                          
+      {
+         "slug":"hamming",
+         "difficulty":3,
+         "topics":[
+            "Strings",
+            "Filtering",
+            "Optional values"
          ]
       },
       {
          "slug":"phone-number",
-         "difficulty":1,
+         "difficulty":3,
          "topics":[
             "Optional values",
             "Strings",
@@ -91,41 +126,24 @@
       },
       {
          "slug":"strain",
-         "difficulty":1,
+         "difficulty":3,
          "topics":[
             "Generics",
             "Sequences",
             "Filtering"
          ]
       },
-      {
-         "slug":"grade-school",
-         "difficulty":1,
-         "topics":[
-            "Maps",
-            "Sequences",
-            "Sorting"
-         ]
-      },
       {
          "slug":"robot-name",
-         "difficulty":1,
+         "difficulty":3,
          "topics":[
             "Strings",
             "Randomness"
          ]
       },
-      {
-         "slug":"leap",
-         "difficulty":1,
-         "topics":[
-            "Integers",
-            "Mathematics"
-         ]
-      },
       {
          "slug":"etl",
-         "difficulty":1,
+         "difficulty":3,
          "topics":[
             "Lists",
             "Maps",
@@ -135,185 +153,183 @@
          ]
       },
       {
-         "slug":"meetup",
-         "difficulty":1,
+         "slug":"grains",
+         "difficulty":3,
          "topics":[
-            "Dates"
+            "Optional values",
+            "Mathematics"
          ]
       },
       {
-         "slug":"space-age",
-         "difficulty":1,
+         "slug":"scrabble-score",
+         "difficulty":3,
          "topics":[
-            "Dates",
-            "Enumerations",
-            "Domain-specific languages"
+            "Strings",
+            "Transforming"
          ]
-      },
+      },      
       {
-         "slug":"grains",
-         "difficulty":1,
+         "slug":"rna-transcription",
+         "difficulty":3,
          "topics":[
             "Optional values",
-            "Mathematics"
+            "Strings",
+            "Transforming"
          ]
       },
       {
-         "slug":"gigasecond",
-         "difficulty":1,
+         "slug":"triangle",
+         "difficulty":3,
          "topics":[
-            "Dates",
-            "Time",
-            "Function Overloading"
+            "Enumerations",
+            "Mathematics"
          ]
       },
       {
-         "slug":"scrabble-score",
-         "difficulty":1,
+         "slug":"binary-search",
+         "difficulty":3,
          "topics":[
-            "Strings",
-            "Transforming"
+            "Searching",
+            "Arrays",
+            "Optional values"
          ]
-      },
+      },            
       {
-         "slug":"difference-of-squares",
-         "difficulty":1,
+         "slug":"secret-handshake",
+         "difficulty":3,
          "topics":[
-            "Integers",
-            "Mathematics"
+            "Lists",
+            "Strings",
+            "Bitwise operations"
          ]
       },
       {
-         "slug":"accumulate",
-         "difficulty":1,
+         "slug":"sieve",
+         "difficulty":3,
          "topics":[
-            "Generics",
-            "Lists",
-            "Transforming"
+            "Filtering",
+            "Mathematics",
+            "Lists"
          ]
       },
       {
-         "slug":"sublist",
-         "difficulty":1,
+         "slug":"robot-simulator",
+         "difficulty":3,
          "topics":[
-            "Generics",
             "Enumerations",
-            "Lists"
+            "Tuples"
          ]
       },
       {
-         "slug":"rna-transcription",
-         "difficulty":1,
+         "slug":"isogram",
+         "difficulty":3,
          "topics":[
-            "Optional values",
             "Strings",
-            "Transforming"
+            "Filtering"
          ]
       },
       {
-         "slug":"triangle",
-         "difficulty":1,
+         "slug":"clock",
+         "difficulty":3,
          "topics":[
-            "Enumerations",
-            "Mathematics"
+            "Time",
+            "Structural equality"
          ]
       },
       {
-         "slug":"roman-numerals",
-         "difficulty":1,
+         "slug":"matrix",
+         "difficulty":4,
          "topics":[
-            "Sequences",
-            "Algorithms",
-            "Transforming"
+            "Strings",
+            "Matrices",
+            "Parsing",
+            "Vectors"
          ]
       },
       {
-         "slug":"binary-search",
-         "difficulty":1,
+         "slug":"house",
+         "difficulty":4,
          "topics":[
-            "Searching",
-            "Arrays",
-            "Optional values"
+            "Strings",
+            "Text formatting",
+            "Algorithms"
          ]
       },
       {
-         "slug":"prime-factors",
-         "difficulty":1,
+         "slug":"series",
+         "difficulty":4,
          "topics":[
-            "Lists",
-            "Integers",
-            "Algorithms",
-            "Mathematics"
+            "Strings",
+            "Sequences",
+            "Transforming"
          ]
       },
       {
-         "slug":"raindrops",
-         "difficulty":1,
+         "slug":"word-count",
+         "difficulty":4,
          "topics":[
+            "Maps",
             "Strings",
-            "Logic",
             "Transforming"
          ]
       },
       {
-         "slug":"allergies",
-         "difficulty":1,
+         "slug":"anagram",
+         "difficulty":4,
          "topics":[
-            "Lists",
-            "Enumerations",
+            "Sequences",
+            "Strings",
             "Filtering"
          ]
       },
       {
-         "slug":"simple-linked-list",
-         "difficulty":1,
+         "slug":"nucleotide-count",
+         "difficulty":4,
          "topics":[
-            "Classes",
-            "Lists",
-            "Transforming",
-            "Generics"
+            "Maps",
+            "Strings"
          ]
       },
       {
-         "slug":"atbash-cipher",
-         "difficulty":1,
+         "slug":"meetup",
+         "difficulty":4,
          "topics":[
-            "Strings",
-            "Transforming",
-            "Security"
+            "Dates"
          ]
       },
       {
-         "slug":"all-your-base",
-         "difficulty":1,
+         "slug":"prime-factors",
+         "difficulty":4,
          "topics":[
-            "Integers",
             "Lists",
-            "Optional values",
-            "Mathematics",
-            "Transforming"
+            "Integers",
+            "Algorithms",
+            "Mathematics"
          ]
       },
       {
-         "slug":"bank-account",
-         "difficulty":1,
+         "slug":"allergies",
+         "difficulty":4,
          "topics":[
-            "Parallellism"
+            "Lists",
+            "Enumerations",
+            "Filtering"
          ]
       },
       {
-         "slug":"crypto-square",
-         "difficulty":1,
+         "slug":"all-your-base",
+         "difficulty":4,
          "topics":[
-            "Strings",
+            "Integers",
             "Lists",
-            "Security",
+            "Optional values",
+            "Mathematics",
             "Transforming"
          ]
       },
       {
          "slug":"kindergarten-garden",
-         "difficulty":1,
+         "difficulty":4,
          "topics":[
             "Enumerations",
             "Transforming",
@@ -321,147 +337,147 @@
          ]
       },
       {
-         "slug":"robot-simulator",
-         "difficulty":1,
-         "topics":[
-            "Enumerations",
-            "Tuples"
-         ]
-      },
-      {
-         "slug":"isogram",
-         "difficulty":1,
+         "slug":"largest-series-product",
+         "difficulty":4,
          "topics":[
             "Strings",
-            "Filtering"
+            "Integers",
+            "Optional values",
+            "Transforming",
+            "Mathematics"
          ]
       },
       {
-         "slug":"bracket-push",
-         "difficulty":1,
+         "slug":"pascals-triangle",
+         "difficulty":4,
          "topics":[
-            "Strings",
-            "Parsing"
+            "Control-flow (loops)",
+            "Lists",
+            "Mathematics"
          ]
       },
       {
-         "slug":"queen-attack",
-         "difficulty":1,
+         "slug":"pythagorean-triplet",
+         "difficulty":4,
          "topics":[
-            "Strings",
-            "Optional values",
-            "Logic",
-            "Games"
+            "Integers",
+            "Mathematics",
+            "Sequences",
+            "Tuples"
          ]
       },
       {
-         "slug":"binary-search-tree",
-         "difficulty":1,
+         "slug":"saddle-points",
+         "difficulty":4,
          "topics":[
-            "Searching",
+            "Matrices",
             "Lists",
-            "Trees",
-            "Generics"
-         ]
-      },
-      {
-         "slug":"largest-series-product",
-         "difficulty":1,
-         "topics":[
-            "Strings",
-            "Integers",
-            "Optional values",
-            "Transforming",
-            "Mathematics"
+            "Sets",
+            "Tuples"
          ]
       },
       {
-         "slug":"luhn",
-         "difficulty":1,
+         "slug":"acronym",
+         "difficulty":4,
          "topics":[
             "Strings",
-            "Algorithms",
             "Transforming"
          ]
       },
       {
-         "slug":"perfect-numbers",
-         "difficulty":1,
+         "slug":"run-length-encoding",
+         "difficulty":5,
          "topics":[
-            "Enumerations",
-            "Integers",
-            "Mathematics"
+            "Algorithms",
+            "Transforming",
+            "Strings"
+         ]
+      },      
+      {
+         "slug":"roman-numerals",
+         "difficulty":5,
+         "topics":[
+            "Sequences",
+            "Algorithms",
+            "Transforming"
          ]
       },
       {
-         "slug":"clock",
-         "difficulty":1,
+         "slug":"simple-linked-list",
+         "difficulty":5,
          "topics":[
-            "Time",
-            "Structural equality"
+            "Classes",
+            "Lists",
+            "Transforming",
+            "Generics"
          ]
       },
       {
-         "slug":"matrix",
-         "difficulty":1,
+         "slug":"atbash-cipher",
+         "difficulty":5,
          "topics":[
             "Strings",
-            "Matrices",
-            "Parsing",
-            "Vectors"
+            "Transforming",
+            "Security"
          ]
       },
       {
-         "slug":"house",
-         "difficulty":1,
+         "slug":"simple-cipher",
+         "difficulty":5,
          "topics":[
+            "Optional values",
             "Strings",
-            "Text formatting",
-            "Algorithms"
+            "Algorithms",
+            "Transforming"
          ]
       },
       {
-         "slug":"zebra-puzzle",
-         "difficulty":1,
+         "slug":"bank-account",
+         "difficulty":5,
          "topics":[
-            "Logic"
+            "Parallellism"
          ]
       },
       {
-         "slug":"minesweeper",
-         "difficulty":1,
+         "slug":"crypto-square",
+         "difficulty":5,
          "topics":[
-            "Lists",
             "Strings",
-            "Parsing",
+            "Lists",
+            "Security",
             "Transforming"
          ]
       },
       {
-         "slug":"ocr-numbers",
-         "difficulty":1,
+         "slug":"bracket-push",
+         "difficulty":5,
          "topics":[
-            "Lists",
             "Strings",
-            "Parsing",
-            "Pattern recognition",
-            "Transforming"
+            "Parsing"
          ]
       },
       {
-         "slug":"wordy",
-         "difficulty":1,
+         "slug":"queen-attack",
+         "difficulty":5,
          "topics":[
-            "Mathematics",
+            "Strings",
             "Optional values",
-            "Parsing",
+            "Logic",
+            "Games"
+         ]
+      },
+      {
+         "slug":"luhn",
+         "difficulty":5,
+         "topics":[
             "Strings",
+            "Algorithms",
             "Transforming"
          ]
       },
       {
          "slug":"food-chain",
-         "difficulty":1,
+         "difficulty":5,
          "topics":[
             "Text formatting",
             "Algorithms"
@@ -469,7 +485,7 @@
       },
       {
          "slug":"linked-list",
-         "difficulty":1,
+         "difficulty":5,
          "topics":[
             "Lists",
             "Generics",
@@ -478,16 +494,28 @@
       },
       {
          "slug":"custom-set",
-         "difficulty":1,
+         "difficulty":5,
          "topics":[
             "Sets",
             "Lists",
             "Generics"
          ]
       },
+      {
+         "slug":"parallel-letter-frequency",
+         "difficulty":5,
+         "topics":[
+            "Maps",
+            "Sequences",
+            "Strings",
+            "Parallellism",
+            "Transforming",
+            "Dictionaries"
+         ]
+      },
       {
          "slug":"nth-prime",
-         "difficulty":1,
+         "difficulty":6,
          "topics":[
             "Optional values",
             "Algorithms",
@@ -496,7 +524,7 @@
       },
       {
          "slug":"palindrome-products",
-         "difficulty":1,
+         "difficulty":6,
          "topics":[
             "Sets",
             "Strings",
@@ -505,102 +533,95 @@
          ]
       },
       {
-         "slug":"pascals-triangle",
-         "difficulty":1,
+         "slug":"ocr-numbers",
+         "difficulty":6,
          "topics":[
-            "Control-flow (loops)",
             "Lists",
-            "Mathematics"
+            "Strings",
+            "Parsing",
+            "Pattern recognition",
+            "Transforming"
          ]
       },
-      {
+       {
          "slug":"pig-latin",
-         "difficulty":1,
+         "difficulty":6,
          "topics":[
             "Strings",
             "Transforming"
          ]
       },
       {
-         "slug":"pythagorean-triplet",
-         "difficulty":1,
+         "slug":"binary-search-tree",
+         "difficulty":6,
          "topics":[
-            "Integers",
-            "Mathematics",
-            "Sequences",
-            "Tuples"
+            "Searching",
+            "Lists",
+            "Trees",
+            "Generics"
          ]
       },
       {
-         "slug":"saddle-points",
-         "difficulty":1,
+         "slug":"rail-fence-cipher",
+         "difficulty":6,
          "topics":[
-            "Matrices",
-            "Lists",
-            "Sets",
-            "Tuples"
+            "Strings",
+            "Algorithms",
+            "Transforming"
          ]
       },
       {
-         "slug":"say",
-         "difficulty":1,
+         "slug":"bowling",
+         "difficulty":6,
          "topics":[
-            "Strings",
-            "Transforming",
-            "Text formatting",
-            "Optional values"
+            "Algorithms",
+            "Control-flow (if-else statements)",
+            "Lists"
          ]
-      },
+      },      
       {
-         "slug":"alphametics",
-         "difficulty":1,
+         "slug":"dominoes",
+         "difficulty":7,
          "topics":[
-            "Maps",
+            "Lists",
             "Optional values",
-            "Strings",
-            "Parsing"
+            "Tuples",
+            "Games"
          ]
       },
-      {
-         "slug":"secret-handshake",
-         "difficulty":1,
+     {
+         "slug":"sublist",
+         "difficulty":7,
          "topics":[
-            "Lists",
-            "Strings",
-            "Bitwise operations"
+            "Generics",
+            "Enumerations",
+            "Lists"
          ]
       },
       {
-         "slug":"series",
-         "difficulty":1,
+         "slug":"minesweeper",
+         "difficulty":7,
          "topics":[
+            "Lists",
             "Strings",
-            "Sequences",
+            "Parsing",
             "Transforming"
          ]
       },
       {
-         "slug":"sieve",
-         "difficulty":1,
+         "slug":"wordy",
+         "difficulty":7,
          "topics":[
-            "Filtering",
             "Mathematics",
-            "Lists"
-         ]
-      },
-      {
-         "slug":"simple-cipher",
-         "difficulty":1,
-         "topics":[
             "Optional values",
+            "Parsing",
             "Strings",
-            "Algorithms",
             "Transforming"
          ]
       },
       {
          "slug":"change",
-         "difficulty":1,
+         "difficulty":7,
          "topics":[
             "Integers",
             "Lists",
@@ -610,7 +631,7 @@
       },
       {
          "slug":"connect",
-         "difficulty":1,
+         "difficulty":8,
          "topics":[
             "Recursion",
             "Graphs",
@@ -621,55 +642,60 @@
          ]
       },
       {
-         "slug":"rail-fence-cipher",
-         "difficulty":1,
+         "slug":"zebra-puzzle",
+         "difficulty":8,
          "topics":[
-            "Strings",
-            "Algorithms",
-            "Transforming"
+            "Logic"
          ]
       },
       {
-         "slug":"dominoes",
-         "difficulty":1,
+         "slug":"say",
+         "difficulty":8,
          "topics":[
-            "Lists",
-            "Optional values",
-            "Tuples",
-            "Games"
+            "Strings",
+            "Transforming",
+            "Text formatting",
+            "Optional values"
          ]
       },
       {
-         "slug":"parallel-letter-frequency",
-         "difficulty":1,
+         "slug":"alphametics",
+         "difficulty":9,
          "topics":[
             "Maps",
-            "Sequences",
+            "Optional values",
             "Strings",
-            "Parallellism",
-            "Transforming",
-            "Dictionaries"
+            "Parsing"
          ]
       },
       {
          "slug":"sgf-parsing",
-         "difficulty":1,
+         "difficulty":9,
          "topics":[
             "Parsing",
             "Transforming"
          ]
       },
       {
-         "slug":"acronym",
-         "difficulty":1,
+         "slug":"lens-person",
+         "difficulty":9,
          "topics":[
-            "Strings",
-            "Transforming"
+
+         ]
+      },
+      {
+         "slug":"variable-length-quantity",
+         "difficulty":9,
+         "topics":[
+            "Discriminated unions",
+            "Lists",
+            "Algorithms",
+            "Bitwise operations"
          ]
       },
       {
          "slug":"zipper",
-         "difficulty":1,
+         "difficulty":10,
          "topics":[
             "Generics",
             "Optional values",
@@ -678,38 +704,12 @@
       },
       {
          "slug":"forth",
-         "difficulty":1,
+         "difficulty":10,
          "topics":[
             "Strings",
             "Mathematics",
             "Parsing"
          ]
-      },
-      {
-         "slug":"lens-person",
-         "difficulty":1,
-         "topics":[
-
-         ]
-      },
-      {
-         "slug":"bowling",
-         "difficulty":6,
-         "topics":[
-            "Algorithms",
-            "Control-flow (if-else statements)",
-            "Lists"
-         ]
-      },
-      {
-         "slug":"variable-length-quantity",
-         "difficulty":1,
-         "topics":[
-            "Discriminated unions",
-            "Lists",
-            "Algorithms",
-            "Bitwise operations"
-         ]
       }
    ],
    "deprecated":[