Another update from ingydotnet^djgoku

Task/Set/Elixir/set.elixir

@@ -0,0 +1,26 @@
+iex(101)> s = HashSet.new
+#HashSet<[]>
+iex(102)> sa = Set.put(s, :a)
+#HashSet<[:a]>
+iex(103)> sab = Set.put(sa, :b)
+#HashSet<[:b, :a]>
+iex(104)> sbc = Enum.into([:b,:c], HashSet.new)
+#HashSet<[:c, :b]>
+iex(105)> Set.member?(sa, :a)
+true
+iex(106)> Set.member?(sa, :b)
+false
+iex(107)> Set.union(sab, sbc)
+#HashSet<[:c, :b, :a]>
+iex(108)> Set.intersection(sab, sbc)
+#HashSet<[:b]>
+iex(109)> Set.difference(sab, sbc)
+#HashSet<[:a]>
+iex(110)> Set.disjoint?(sab, sbc)
+false
+iex(111)> Set.subset?(sa, sab)
+true
+iex(112)> Set.subset?(sab, sa)
+false
+iex(113)> sa == sab
+false

Task/Set/Frink/set.frink

@@ -0,0 +1,9 @@
+a = new set[1, 2]
+b = toSet[[2,3]]   // Construct a set from an array
+
+a.contains[2]  // Element test (returns true)
+union[a,b]
+intersection[a,b]
+setDifference[a,b]
+isSubset[a,b]  // Returns true if a is a subset of b
+a==b           // set equality test

Task/Set/J/set-4.j

@@ -1 +1 @@
-properSubset=: subset *. 1 - equality
+properSubset=: subset * 1 - equality

Task/Set/JavaScript/set.js

@@ -0,0 +1,24 @@
+var set = new Set();
+
+set.add(0);
+set.add(1);
+set.add('two');
+set.add('three');
+
+set.has(0); //=> true
+set.has(3); //=> false
+set.has('two'); // true
+set.has(Math.sqrt(4)); //=> true
+set.has('TWO'.toLowerCase()); //=> true
+
+set.size; //=> 4
+
+set.delete('two');
+set.has('two'); //==> false
+set.size; //=> 3
+
+//iterating set using ES6 for..of
+//Set order is preserved in order items are added.
+for (var item of set) {
+  console.log('item is ' + item);
+}

Task/Set/OCaml/set.ocaml

@@ -27,18 +27,18 @@ module IntSet :
     val max_elt : t -> elt
     val choose : t -> elt
     val split : elt -> t -> t * bool * t
+    val find : elt -> t -> elt
+    val of_list : elt list -> t
   end
 # IntSet.empty;; (* Empty set. A set is an abstract type that will not display in the interpreter *)
 - : IntSet.t = <abstr>
 # IntSet.elements (IntSet.empty);; (* Get the previous set into a list *)
 - : IntSet.elt list = []
-# let from_list lst = List.fold_right IntSet.add lst IntSet.empty;; (* Convenience function for constructing a set from a list *)
-val from_list : IntSet.elt list -> IntSet.t = <fun>
-# let s1 = from_list [1;2;3;4;3];;
+# let s1 = IntSet.of_list [1;2;3;4;3];;
 val s1 : IntSet.t = <abstr>
 # IntSet.elements s1;;
 - : IntSet.elt list = [1; 2; 3; 4]
-# let s2 = from_list [3;4;5;6];;
+# let s2 = IntSet.of_list [3;4;5;6];;
 val s2 : IntSet.t = <abstr>
 # IntSet.elements s2;;
 - : IntSet.elt list = [3; 4; 5; 6]
@@ -50,9 +50,9 @@ val s2 : IntSet.t = <abstr>
 - : IntSet.elt list = [1; 2]
 # IntSet.subset s1 s1;; (* Subset *)
 - : bool = true
-# IntSet.subset (from_list [3;1]) s1;;
+# IntSet.subset (IntSet.of_list [3;1]) s1;;
 - : bool = true
-# IntSet.equal (from_list [3;2;4;1]) s1;; (* Equality *)
+# IntSet.equal (IntSet.of_list [3;2;4;1]) s1;; (* Equality *)
 - : bool = true
 # IntSet.equal s1 s2;;
 - : bool = false

Task/Set/Rust/set.rust

@@ -0,0 +1,15 @@
+use std::collections::HashSet;
+
+fn main() {
+  let a = vec![1, 3, 4].into_iter().collect::<HashSet<i32>>();
+  let b = vec![3, 5, 6].into_iter().collect::<HashSet<i32>>();
+
+  println!("Set A: {:?}", a.iter().collect::<Vec<_>>());
+  println!("Set B: {:?}", b.iter().collect::<Vec<_>>());
+  println!("Does A contain 4? {}", a.contains(&4));
+  println!("Union: {:?}", a.union(&b).collect::<Vec<_>>());
+  println!("Intersection: {:?}", a.intersection(&b).collect::<Vec<_>>());
+  println!("Difference: {:?}", a.difference(&b).collect::<Vec<_>>());
+  println!("Is A a subset of B? {}", a.is_subset(&b));
+  println!("Is A equal to B? {}", a == b);
+}

Task/Set/SETL/set.setl

@@ -0,0 +1,10 @@
+A := {1, 2, 3, 4};
+B := {3, 4, 5, 6};
+C := {4, 5};
+
+-- Union, Intersection, Difference, Subset, Equality
+print(A + B);       -- {1, 2, 3, 4, 5, 6}
+print(A * B);       -- {3, 4}
+print(A - B);       -- {1, 2}
+print(C subset B);  -- #T
+print(C = B);       -- #F