När livet inte längre lockar

<div class="kv-article-audio-player">  <div class="kv-aap-listen">    <div class="kv-listen-left">      <span>        <i class="fas fa-headphones-alt"></i>      </span>    </div>    <div class="kv-aap-listen-right">Lyssna på texten    </div>  </div><div id    = "kv-pod-holder-184502"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-tis="1200" data-tin="1399" data-pid="184502" data-pty="SW5sw6RzdCBhcnRpa2VsIChTYW1ow6RsbGUp" data-pna="TsOkciBsaXZldCBpbnRlIGzDpG5ncmUgbG9ja2Fy" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2UvaW5sYXN0YXRleHRlci85LTI2LW5hci1saXZldC1pbnRlLWxhbmdyZS1sb2NrYXIubXAz" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvOS0yNi1uYXItbGl2ZXQtaW50ZS1sYW5ncmUtbG9ja2FyLm1wMw==">  <div class="kv-pod-holder-inner">    Laddar <span class="blink-me">...</span>  </div></div>  <div class="kv-listen-subscribe">    <span>Följ Kvartals poddar:</span>    <a target="_blank" href="https://podcasts.apple.com/se/podcast/kvartal/id1447122576?mt=2">Apple</a>    |     <a target="_blank" href="https://open.spotify.com/show/6NsieE1iFLypikr3slKII0?si=ppaUJpA3R-mo8L9L4XgudA">Spotify</a>  </div></div><div class="kvartal-meta clearfix" style="color: ">Av <a href="https://kvartal.se/medverkande/johan-frostegard/">Johan&nbsp;Frostegård</a> | 11 augusti 2025<div style="float: right;" class="social-top-wrapper closed no-comments"><div class="share-icons"><span class="share-outer"><a href="https://www.facebook.com/sharer.php?u=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fnar-livet-inte-langre-lockar%2F&amp;t=N%C3%A4r+livet+inte+l%C3%A4ngre+lockar"    target="_blank"    class="fb-link"    title="Dela på facebook"><i class="fa fa-facebook ui transparent"></i></a><a href   = "https://twitter.com/intent/tweet?text=N%C3%A4r+livet+inte+l%C3%A4ngre+lockar+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fnar-livet-inte-langre-lockar%2F"    target = "_blank"    class  = "tw-link"    title  = "Dela på X.com"><i class="exticon exticon-x-icon"></i></a></span><span class="share-inner"><a href   = "http://www.linkedin.com/shareArticle?mini=true&url=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fnar-livet-inte-langre-lockar%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=När livet inte längre lockar&body=https://kvartal.se/artiklar/nar-livet-inte-langre-lockar/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/184502/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer ui transparent"></i></a></span><a href="#share" class="share-expand "    title="Visa fler delningsalternativ"><i class="fas fa-share-square ui transparent"></i></a></div></div></div><div class="kv-art-ext-sep"></div><div class="mobile-share clearfix" style="margin-top: -10px; margin-bottom: 20px;"><div class="share-icons"><span class="share-outer"><a href="https://www.facebook.com/sharer.php?u=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fnar-livet-inte-langre-lockar%2F&amp;t=N%C3%A4r+livet+inte+l%C3%A4ngre+lockar"    target="_blank"    class="fb-link"    title="Dela på facebook"><i class="fa fa-facebook ui transparent"></i></a><a href   = "https://twitter.com/intent/tweet?text=N%C3%A4r+livet+inte+l%C3%A4ngre+lockar+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fnar-livet-inte-langre-lockar%2F"    target = "_blank"    class  = "tw-link"    title  = "Dela på X.com"><i class="exticon exticon-x-icon"></i></a></span><span class="share-inner"><a href   = "http://www.linkedin.com/shareArticle?mini=true&url=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fnar-livet-inte-langre-lockar%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=När livet inte längre lockar&body=https://kvartal.se/artiklar/nar-livet-inte-langre-lockar/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/184502/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer ui transparent"></i></a></span><a href="#share" class="share-expand "    title="Visa fler delningsalternativ"><i class="fas fa-share-square ui transparent"></i></a></div></div><div class="article-actions"><a href="/profile" class="kv-aa-profile"><svg aria-hidden="true">  <use href="#tf-ti-user"></use></svg><span>Profil</span></a><a class="listen" href="https://kvartal.se/artiklar/nar-livet-inte-langre-lockar/?inlast=1">  <i class="fas fa-headphones-alt"></i>  <span>Inlästa texter</span></a><a href="#nyhetsbrevet" onclick="newsletter()" class="newsletter"><i class="fas fa-paper-plane"></i><span>Nyhetsbrev</span></a><a class="reading-time" title="Ungefärlig lästid"><i class="far fa-clock ui"></i><span>Lästid 12 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/ee8acfdb-668c-4514-b12f-3e6d2936a142"    target = "_blank"    class  = "screen-reader-friendly"    title. = "Version som fungerar bättre med skärmläsarprogramvara">  <i class="fas fa-volume-up"></i>  <span>Skärmläsarvänlig</span></a></div><div class="in-short-wrapper closed" id="in-short-184502">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "184502"></span>    <i class="themify-icon-icon fas fa-align-left"></i>    <span class="in-short-heading">I korthet</span>    <hr class="in-short-divider" />    <div class="in-short-text">    </div>  </div></div><div class="article-beginning ">Vi lever i en polariserad tid där alltmer dras in i algoritmernas dans, som torra löv om hösten. Kulturkriget rasar, liksom mediadreven, och politiken i synnerhet och ideologi i allmänhet tycks ha blivit religionssubstitut.</p>
</div>
<div class="rest-of-article ">
<p>Klimatfrågan har sedan länge gått den vägen, liksom Palestinafrågan. Dessa går inte lätt att diskutera i ett offentligt samtal utan att tesen om religionssubstitut illustreras; man kallas förnekare – av klimat eller folkmord. En fråga som i Sverige däremot är rätt sval numera, i motsats till på många andra håll, är som bekant abortfrågan.</p>
<p>Hur det har blivit så polariserat är inte ämnet här, utan jag tänkte fokusera på en annan mycket känslig fråga: dödshjälp, eller eutanasi, som i skrivande stund inte ter sig politiserad i Sverige – men detta kan förstås ändras. Den traditionella läkaretiken, rentav läkareden (som är avskaffad i Sverige), med anor från <strong>Hippokrates</strong>, är mycket tydlig: ”Jag ska inte ge någon gift, även om jag blir ombedd, ej heller ordinera något sådant.”</p>
<p>Jag kan inte hitta någon definition på Socialstyrelsen eller Svenska Läkaresällskapet, men Sveriges Läkarförbund har diskuterat <a href="https://slf.se/rad-och-stod/etik/dodshjalp/">frågan</a>: Dödshjälp delas upp i: 1. Eutanasi – genom att någon annan än patienten utför den avgörande handling som leder till patientens död. 2. Assisterat döende – dödshjälp där patienten själv utför den avgörande handlingen.</p>
<p>Ofta finns tillägg, till exempel att man ska förväntas dö inom sex månader enligt läkarbedömning och är vid sina sinnens fulla bruk. Ibland är termen aktiv dödshjälp, i motsats till passiv dödshjälp, som dock är ett oegentligt begrepp, eftersom det bara är vanlig god sjukvård där man helt enkelt låter patienten dö av sin obotliga sjukdom med god palliativ vård.</p>
<h2>Abort och dödshjälp</h2>
<p>Ibland sägs det att abort och dödshjälp är frågor som är besläktade, och så hamnar dödshjälpsmotståndaren i liknande predikament som abortmotståndaren, eller för den delen moderna ”förnekare” av olika slag, i en rejäl uppförsbacke. Men i själva verket är motsatsen fallet. Abort handlar om att man dödar någon som inte vill dö och som inte anses vara människa (här ska man komma ihåg att inte heller kyrkan anordnar begravning vid missfall i allmänhet), således raka motsatsen till dödshjälp. Man bör alltså helt bortse från abortfrågan när det gäller dödshjälp.</p>
<p>Dödshjälp är tillåtet i ett flertal länder, där Nederländerna var tidigt ute, och i Schweiz finns dödshjälp sedan länge att köpa vid speciella inrättningar. Så är fallet även i vissa amerikanska delstater samt i Kanada, till exempel. Är dödshjälp på frammarsch? Det kan tyckas så men vi får väl se.</p>
<p>För egen del är jag negativ till en legalisering av dödshjälp, eftersom detta för med sig för stora risker – för patienterna i första hand, men även för läkarna och annan sjukvårdspersonal samt för samhället i stort. Vad som är en möjlighet blir snabbt en förväntan och senare en skyldighet, och i praktiken har det <a href="https://pubmed.ncbi.nlm.nih.gov/35795029/">visat sig</a> att dödshjälp ges även till psykiskt sjuka människor utan kroppslig sjukdom i vanlig mening, vilket jag finner mycket olustigt. Svår smärta är ett sådant argument som blivit mindre relevant, eftersom man numera kan ge god palliativ vård och i livets slutskede kan man sova in i döden.</p>
<p>Ett vanligt skäl att vilja ha dödshjälp är att man inte vill ligga andra till last. Själv tycker jag att detta är obehagligt och att det måhända illustrerar ett förakt för svaghet i vårt samhälle, som inte bara handlar om svårt sjuka åldringar vid dödens port utan om alla möjliga människor med handikapp och kronisk sjukdom där omvårdnaden försämras eller rentav sätts på undantag. Kort sagt kan det bli frågan om en modern ättestupa.</p>
<p>En möjlighet blir en förväntan.</p>
<h2>Självbestämmandet</h2>
<p>Det starkaste argumentet för legalisering av aktiv dödshjälp, tänker jag, är självbestämmande. Vi har mänskliga rättigheter och har rätt att bestämma över våra liv. Dessutom är det inte, som det var förr, olagligt att begå självmord. Problemet är den andre, som dödar. Vad säger man om dessa svåra och obehagliga frågor i skönlitteraturen?</p>
<p>En tidig proponent för självbestämmande när det gäller självmord är doktor <strong>Henrik Borg</strong> i <strong>Strindbergs</strong> <em>Röda rummet</em>. Borg är en av romanens mest färgstarka personligheter. Det är en brysk läkare, eller rätteligen blivande läkare, från välbärgad familj eftersom han klarar sig bra som växelryttare, som finansierar sitt rätt så vidlyftiga leverne inklusive studier vid Karolinska institutet, genom lån vilka finansieras med nya lån i andra banker.</p>
<p>Borg är tydlig när det gäller självmord, han har ”alltid ansett självmord vara en av människans heligaste rättigheter eftersom hon fått den gåvan av naturen” och då ska vi komma ihåg att dödshjälp i sin vanliga definition är självmord – med komplikationen att en annan person sköter själva dödandet. Ingenstans tycks Borg vara beredd att ge dödshjälp.</p>
<p>Han ter sig i boken som en framtidens man. Naturvetenskapen var på frammarsch och kunskaperna om sjukdomars orsaker hade ökat dramatiskt även om botemedlen var relativt få. Strindbergs romanfigur Borg visar en intressant aspekt av läkaryrket, som Strindberg för övrigt var väl förtrogen med – han var ju både läkarassistent hos societetsläkare i Stockholm och läkarstudent en period. Denna aspekt handlar om distans; en läkare måste kunna betrakta sin patient objektivt, kyligt om man så vill, samla ihop symtom och framför allt upplysa sig om sjukhistorien som i allmänhet är det viktigaste. Därefter ställs diagnos, ofta tentativ, som sedan bara är en utgångspunkt. Vad man gör sedan är det svåraste i läkarjobbet, inte själva diagnosställandet.</p>
<p>Borg excellerar i detta kyliga betraktande: ”Som du vet betraktar jag människorna med den absoluta likgiltighetens blickar; jag tar dem som geologiska preparat, som mineralier…” Denna distanserade kylighet för med sig risker och måste balanseras av strikt läkaretik, helst empati, men somliga läkare är inte empatiska, tyvärr.</p>
<p><strong>Arvid Falk</strong>, huvudpersonen i <em>Röda rummet</em>, är nergången när Borg hämtar honom tillsammans med en kompis, <strong>Isaac</strong>. Falk sitter och dricker brännvin på förmiddagen med ett par ”skandalskrivare” på ett sjabbigt hak vid Kindstugatan i Gamla stan, dåförtiden en rätt nedgången lokalmiljö, samt skriver på recensioner av pjäser han inte sett och gör ner folk på order av redaktören, en dåtida variant på dagens mediedrev. De tar Borg i hampan och far genast ut till skärgården, där Borgs avsikt är att få Falk på fötter och bota hans depression. Vilket lyckas, någon månad senare är Falk återställd. Däremot gör Borg inget när Falk tar långa simturer på fjärden, även om han misstänker att denne funderar på självmord. Borgs agerande är väl värt att diskutera, nog borde han försöka förhindra ett självmord om han misstänkte ett sådant även om Falk inte formellt var hans patient.</p>
<p>Så tog en annan huvudkaraktär i <em>Röda rummet</em>, <strong>Olle Montanus</strong>, livet av sig. Han dränkte sig i Stockholms svarta vatten, och Borg konstaterar även där lakoniskt att självmord är en rättighet. Däremot finns det inget som tyder på att Borg hade ställt upp på att hjälpa någon över kanten, med gift.</p>
<h2>Läkaretikens svaga ställning</h2>
<p>Läkaretiken har som jag beskrivit tidigare i <a href="https://kvartal.se/artiklar/har-vi-avskaffat-lakaretiken-i-det-tysta/">Kvartal</a> en svag ställning idag. Läkareden finns inte längre och läkaretiken tycks avskaffad, eller åtminstone försvagad, åtminstone om man söker på de stora universitetssjukhusens hemsidor. Där finns däremot ord som värdegrund i överflöd. Så om dödshjälp tillåts kan den snabbt bli en del av värdegrunden och läkare kan inte hänvisa till läkaretiken.</p>
<p>Läkaretiken finns för att skydda patienten, som alltid är i underläge gentemot läkaren hur vården än är organiserad, och för att skydda läkaren mot tredje part, till exempel den som betalar. Samt mot patienten också för den delen. Här finns också förtroendet för sjukvården i vågskålen. Vi kan nog räkna med att det blir läkare som får ge dödshjälpen, även om sjuksköterskor kanske också kommer ifråga; det är ju de som oftast delar ut mediciner och sätter nål och ger injektioner.</p>
<p>För att fortsätta exemplen ur litteraturen så måste <strong>doktor Glas</strong> vara den mest berömde läkaren i åtminstone svensk litteratur. Man kan genast slå fast att det han gör är inte att ge dödshjälp i någon rimlig definition av saken – han är helt enkelt en mördare. Däremot är han, som vi ska se, helt för dödshjälp. Pastor <strong>Gregorius</strong>, mordoffret, har åtskilliga år kvar att leva och vill inte dö, tvärtom. Han konsulterar doktor Glas för att leva längre, eller åtminstone vara vid bättre hälsa, men i stället får han ett giftpiller i Kungsträdgården, av doktorn. Mordet är inte perfekt genomfört men nära nog, och Glas slapp undan, då i alla fall. Om dagboken hittades hade han kunnat åka dit. Dödshjälp är det inte, men historien illustrerar ändå ett centralt argument mot dödshjälp, det sluttande planet.</p>
<p>Idén är att dödshjälp, om det väl tillåts, kommer att utvidgas till att omfatta allt fler grupper tills man riskerar att hamna i ett mycket farligt läge, där dyra och obekväma sjuklingar förmås att begära dödshjälp. Argumentet kan självt också hamna i ett sluttande plan om det glider mot det så kallade nazistargumentet som man ska vara försiktig med, men också väl medveten om – det är mycket som finns i vågskålen. Nazisterna bedrev som bekant ”dödshjälp” i stor skala på svaga medborgare av ideologiska skäl, i vad som kallades eutanasi,</p>
<p>Empirin ger stöd åt detta argument, utan att det behöver halka ner i nazistargumentet. Vad som började i begränsad skala har som sagt vidgats i och med att man ger dödshjälp i bland annat Kanada och Nederländerna åt folk som inte är döende eller förväntas dö snart, eller som är psykiskt sjuka eller lider av demens.</p>
<h2>Förberett självmord</h2>
<p>Doktor Glas, denne välskrivande läkare och mördare, har förberett självmord för egen del. Han har flera cyankaliumtabletter gömda i chiffonjén, senare i ett fickur utan visare, eftersom han ansåg att ”en vis man alltid bör vara beredd”. I bokens inledning citeras en anekdot om den berömde pessimisten <strong>Arthur Schopenhauer</strong>, som ogillade en persons utseende och därför slog personen med en käpp. Glas känner något liknande själv när han ser pastorn som han kommer att ta livet av – en ”förskräcklig fysionomi”, ”otäck svamp”, med gemen blick. Glas har pastorn som patient, och tänker ”du kan gärna dö, din gamla rackare”. Sedan kommer en variant på ett utilitaristiskt tankeexperiment, huruvida man skulle döda någon helt obekant och rik person genom att trycka på en knapp och sedan ärva rikedomarna. Glas skulle döda pastorn om han kunde genom att trycka på en knapp skriver han. Abort var inte tillåtet då, och den gamla läkaretiken säger nej till dåtidens abort där man genom gift eller andra farliga ingrepp åstadkom fosterfördrivning, och Glas är mycket noggrann med att alltid avvisa sådana propåer.</p>
<p>Doktor Glas har inga problem med att ljuga för pastorn om dennes föregivna sjukdom, samt skriver ut digitalis trots att denna hjärtmedicin inte behövs. <strong>Helga</strong> är otrogen mot sin make, pastorn, och säger till doktor Glas att hon skulle kunna mörda sin make.</p>
<blockquote><p>Utan fungerande läkaretik riskerar vi nya Macchiarinis.</p></blockquote>
<p>Glas kan tänka sig självmord till följd av fattigdom, vilket för tankarna till Kanada, där fattigdom <a href="https://www.theguardian.com/world/2024/oct/17/canada-nonterminal-maid-assisted-death">rapporterats</a> som skäl för eutanasi.</p>
<p>Sedan halkar Doktor Glas längre ner på det sluttande planet och hamnar i ett slags proto-nazism. Först skriver han att han skulle ha gett många olyckliga sina giftpiller och strax halkar han ner mer: ”hur mycket odugligt, hopplöst fördärvat människomaterial har jag inte på ämbetets vägnar varit med om att konservera”. Sedan slår han i botten: ”Varje idiot på Eugeniahemmet kostar mera i årligt underhåll än en frisk ung kroppsarbetare har i årlig inkomst.”</p>
<p>Doktor Glas blir bland mycket annat en illustration av det sluttande planet, sådan denna faktiskt tedde sig när nazimedicinen slog igenom i Tyskland och åtminstone i någon mån smittade både här och där, till exempel med rasbiologi.</p>
<h2>Informerat samtycke</h2>
<p><strong>Lars Gyllensten</strong> har också presenterat läkare i romanform som är av intresse i sammanhanget. I <em>Juvenilia</em> från 1965 är Gyllensten ofta både rolig och burlesk, och inte minst är han en mycket skicklig stilist. I <em>Juvenilia</em> är huvudpersonen privatpraktiserande neurolog, i Stockholms finare innerstadskvarter, på Artillerigatan. Doktorn, <strong>Torsten Mannelin</strong>, är liksom Gyllensten författare, men försörjer sig som läkare, liksom mången läkarförfattare inklusive <strong>Bulgakov</strong>, <strong>Celine</strong> och <strong>Tjechov</strong> – och doktor Glas! Här finns en historia som kommer mig att tänka på <strong>Macchiarini</strong>-skandalen, där en karriärlysten forskande kirurg hoppade över alla skaklar, inklusive läkaretiken (och lagen). Gyllenstens huvudperson har en svårt handikappad son, som bor på en institution, och är själv ”tillsyningssläkare vid ett spastikerhem” och i den egenskapen strider han mot forskare som vill bedriva experiment med de intagna i form av ”ympningar”, vaccinationsförsök. Mannelin protesterar ampert.</p>
<p>Informerat samtycke är numera normen i medicinsk forskning, vilket det förstås inte var fråga om här, men å andra sidan bedrivs forskning även på barn. Mannelin reagerar starkt i alla fall och jag låter det vara osagt om det fullt ut är med rätta. Men utan fungerande läkaretik riskerar vi nya Macchiarinis!</p>
<p>Gyllensten uttrycker sig drastiskt om det mänskliga predikamentet: ”Döden är som en skarprättare – han tvingar sitt offer att huka sig innan han hugger i huvudet, och ofta måste man stå länge på huk i ett värnlöst, djuriskt läge.” Se där ett argument för dödshjälp, vilket dock minskat i kraft i takt med bättre palliativ vård.</p>
<p>I <em>Hamlet</em> finns många fantastiska monologer, framförda på jambisk pentameter. Berömd är <strong>Hamlets</strong> utläggning om självmord, <em>Att vara eller inte vara</em>, där kontentan är att många skulle ta livet av sig om de visste vad som händer sedan. Här kan jag hålla med en av romanfigurerna i <em>Röda rummet</em>, nihilisten och skådespelaren <strong>Falander</strong>, om att denna dialog inte är speciellt lyckad idag, när modern ideologi håller människor och deras själar i ett fast grepp.</p>
<p>Strindberg led tidvis av psykiska problem, hade förföljelsetankar och var deprimerad och neurotisk – och verkligen förföljd i Sverige när han blev orättvist behandlad av dåtidens litterära etablissemang. Han illustrerar själv något centralt gällande självmord i <em>En dåres försvarstal.</em> Han överväger självmord men ångrar sig: ”Då greps jag på nytt av levnadslust och övermannades av fruktan för förintelsen. Jag ville absolut inte dö längre…” I <em>Doktor Glas</em> vill hustrun till pastorn som sedan mördas av doktorn dö, vilket hon upprepar ett par gånger. Många ändrar sig och dör alltså inte, och vi vet inte hur de som dör hade agerat om de inte lyckats i sitt uppsåt.</p>
<p>Som läkare blir man för övrigt van att hantera frågeställningen även om man inte är psykiatriker; att vid misstänkt depression fråga om tankar på självmord finns är något läkare gör, och det är inte så känsligt att fråga som man skulle kunna tro. Självmord är något många eller alla tänkt på även om de inte övervägt det, men ska man underlätta självmord?</p>
<p>Vilket man gör vid legalisering av dödshjälp, som är alldeles för riskabelt för att införas.</p>
<div class="author-byline">Johan Frostegård är specialist i internmedicin och reumatologi samt professor i medicin vid Karolinska Institutet.
</div>
</div>
