A simple palindrome without using any inbuilt functions like `String.reverse` or `String.length`

palindrome.ex

defmodule Palindrome do
  def check(<< first :: binary-size(1), rest :: binary >> = actual) do
    check(first, rest, actual)
  end

  def check(newstr, << next_letter :: binary-size(1), rest :: binary >>,  actual) do
    check(next_letter <> newstr, rest, actual)
  end

  def check(reverse, <<>>,  actual), do: reverse === actual
end

palindrome_test.exs

defmodule PalindromeTest do
  use ExUnit.Case
  test "check if palindrome" do
    assert Palindrome.check("elixir") === false
    assert Palindrome.check("madam") === true
  end
end

Bottom case

• assert Palindrome.check("") === true
• assert Palindrome.check(" ") === true

> Palindrome.check ""
** (FunctionClauseError) no function clause matching in Palindrome.check/1
    Palindrome.ex:2: Palindrome.check("")

clojure-version

(defn palin?
  ([actual]
   (palin? actual actual ""))
  ([[first & rest] actual reverse]
   (if (= nil first)
     (= actual reverse)
     (palin? rest actual (str first reverse)))))

(deftest check-palindrome
  (is (not= (palin? "clojure") true))
  (is (= (palin? "aibohphobia") true))
  (is (= (palin? "") true))
  (is (= (palin? " ") true)))

(run-tests)

haskell-version

-- | Check Palindrome 

module Palindrome where

check :: [a] -> Bool
check actual = check_ actual actual []
               where
                 check_ [] actual reverse = actual == reverse
                 check_ (x:xs) actual reverse = check_ xs actual (x:reverse)

elixir-version

defmodule Palindrome do
  def check(actual) do
    check(actual, actual, "")
  end

  def check(<< next_letter :: binary-size(1), rest :: binary >>, actual, reverse) do
    check(rest, actual, next_letter <> reverse)
  end

  def check(<<>>, actual, reverse), do: reverse === actual
end