Values in Elixir are immutable (they cannot be changed once created) - functions like String.replace return a new binary.

You can rebind variables, however. For instance,

  text = String.replace(text, String.slice(text, 72..80), slice2, global: false

After this line, the name text will refer to the result of String.replace instead of the original input.

General note: hardcoding numerical offsets that are passed to String.slice is very likely not what the problem is really looking for. Take a look at the Regex module for a better way to find sequences like “left square bracket followed by letters followed by right square bracket” and manipulate them.

Using string slices is absolutely not what you want here. I’d tell you that you failed the interview if you showed that to me.

Look for ways to search [anything] in the source text and replace that. Regex is a good start and might even be good enough as a final solution.

Yeah I know hard coding numbers are not the proper solution here and I have theoretical solution but struggling to implement that,

I’m a newbie getting into programming and trying my share of struggles, I’ll learn as I practice,
I’ll try regex functions

If I understand the problem correctly you need to replace variable placeholders like [name] with passed in arguments. You can use a Regex to solve this but if the structure of source.txt is exactly as it appears you can also use Elixir binary pattern matching. You can recurse over a binary file and match patterns like [name] [company] [time] [salesguy].

To keep things simple you can pass in a map as an argument

  %{name: "John", company: "Google", time: "3:30pm", salesguy: "Ralph"},

Now with binary pattern matching you can use this map to replace the placeholder variables.

defmodule Replacer do

  defp template do
    Application.app_dir(:replacer, "/priv/source.txt")
  end

  def replace_text(sample_data) when is_map(sample_data) do
    template()
    |> File.read!()
    |> replace(sample_data)
  end

  defp replace(source, sample_data) do
    replace(source, sample_data, [])
  end

  defp replace("", _sample_data, acc) do
    acc
    |> Enum.reverse()
    |> IO.iodata_to_binary()
  end

  defp replace(<<"[name]", rest::binary>>, sample_data, acc) do
    name = sample_data.name
    replace(rest, sample_data, [name | acc])
  end

  defp replace(<<"[company]", rest::binary>>, sample_data, acc) do
    company = sample_data.company
    replace(rest, sample_data, [company | acc])
  end

  defp replace(<<"[time]",  rest::binary>>, sample_data, acc) do
    time = sample_data.time
    replace(rest, sample_data, [time | acc])
  end

  defp replace(<<"[salesguy]",  rest::binary>>, sample_data, acc) do
    salesguy = sample_data.salesguy
    replace(rest, sample_data, [salesguy | acc])
  end

  defp replace(<<head, rest::binary>>, sample_data, acc) do
    replace(rest, sample_data, [head | acc])
  end

end

Now in iex you can

iex(1)>  sample_data = %{name: "John", company: "Google", time: "3:30pm", salesguy: "Ralph"}

iex(2)> iex(2)> Replacer.replace_text(record)
"Hi John,\nThank you for your time in our office.\nThanks for booking at Google for 3:30pm\nRegards\nRalph\n"

Thank you @ericgray it works and I’m trying on regex implementation,
still reading different regex and string related doc’s, articles

Great that’s a good way to learn. Try different things to see what works best for you. Regex patterns are good but they can be cryptic and hard to read. I think in this case where you know the shape of the data before hand binary pattern matching is easier in my opinion. Try a Regex and let us know what you come up with.

Suppose you have a map that stores the attributes you want to stuff into the template, like

attrs = %{
  "name" => "Charlie Bucket",
  "company" => "The Chocolate Factory",
  "time" => "Aug 12, 2021",
  "salesguy" => "Willy Wonka"
}

you can try

# `source` is the content read from `source.txt`
result =
  Enum.reduce(attrs, source, fn {key, value}, acc ->
    String.replace(acc, "[#{key}]", value, global: true)
  end)

or

result = 
  for {key, value} <- attrs, reduce: source do
    acc -> String.replace(acc, "[#{key}]", value, global: true)
  end

Given attrs:

attrs = %{
  "name" => "Charlie Bucket",
  "company" => "The Chocolate Factory",
  "time" => "Aug 12, 2021",
  "salesguy" => "Willy Wonka"
}

and an input string in source, a single call to Regex.replace can do this:

Regex.replace(~r/\[([^\]]+)\]/, source, fn _, key -> attrs[key] end)

This will silently replace unrecognized keys with empty strings; use something like Map.fetch if that isn’t desired.

The regex here looks worse than it is, because square brackets are metacharacters in regex:

• \[ matches a literal open bracket
• ([^\]]+) captures one or more characters that aren’t a ]
• \] matches a literal close bracket

That’s faster than my solution, I guess, since it goes through the template string only once.

If the keys contain only word characters (i.e. a to z, A to Z, numbers, and _), the regex can be simplified as

~r/\[(\w+)\]/