Anagram in golang vs anagram in elixir-lang ; am I missing something obvious here?

anagram.cs

using System.IO;
using System;
using System.Linq;

public class Anagram
{
    // I am aware about, but have no intention on using
    // `string.Equals(a, b, StringComparison.OrdinalIgnoreCase)`
    // as that is longer
    public static string[] Detect(string subject, string[] Candidates) 
    {
        return Candidates
          .Where(x => subject.ToLower() != x.ToLower()
                   && Normalize(subject) == Normalize(x))
          .ToArray();
    }
    
    static string Normalize(string input) {
        var chars = input.ToLower().ToCharArray();
        Array.Sort(chars);
        return new string(chars);
    }
}

anagram.ex

defmodule Anagram do
  def match(subject, candidates) do
    candidates
      |> Enum.filter(fn x -> normalize_word(subject)  == normalize_word(x) end)
      |> Enum.filter(fn x -> String.downcase(subject) != String.downcase(x)end)
  end

  defp normalize_word(word) do
    word |> String.downcase |> String.codepoints |> Enum.sort
  end
end

anagram.go

package anagram

import (
	"sort"
	"strings"
)

func Detect(subject string, candidates []string) []string {
	result := []string{}
	for _, candidate := range candidates {
  	if normalize(subject) == normalize(candidate) &&
    	 strings.ToLower(subject) != strings.ToLower(candidate) {
     	result = append(result, strings.ToLower(candidate))
    }
  }
  return result
}

func normalize(subject string) string {
  runes := []string{}
  for _, Rune := range subject {
    runes = append(runes, strings.ToLower(string(Rune)))
  }
  sort.Strings(runes)
  return strings.Join(runes, "")
}

anagram.hs

import Data.List (sort)
import Data.Char (toUpper)

anagram :: [Char] -> [[Char]] -> [[Char]]
anagram s cs =
  let upCase = map toUpper
      normalize = sort . upCase
      is_anagram x = normalize s == normalize x && upCase s /= upCase x
   in filter is_anagram cs

Ah the lack of comparing it to self; I'll add it!

http://rosettacode.org/wiki/Anagrams#Go
http://rosettacode.org/wiki/Anagrams#Haskell ;-)

In C#

IEnumerable<string> Anagrams(string subject,IEnumerable<string> candidates)
{
    Func<string,string> canonize =  s => new string(s.ToLower()
                                                     .OrderBy(c => c).ToArray());
    return candidates.Where(that => canonize(subject) == canonize(that) 
                                    && subject.ToLower() != that.ToLower());
}

@abolibibelot Agreed, that is shorter than my example; Linq FTW!

But I agree the pipe/thrush operator in Elixir/F# is nicer.

Re the Haskell code, why not use String -> [String] -> [String] instead of [Char] -> [[Char]] -> [[Char]]?

By chance, can we get perf numbers on these?